Modifications entre les versions 1 et 9 (s'étendant sur 8 versions)
Version 1 à la date du 2012-11-21 20:00:26
Taille: 57
Éditeur: roq13-2-78-235-210-46
Commentaire:
Version 9 à la date du 2012-11-21 21:31:28
Taille: 4080
Éditeur: roq13-2-78-235-210-46
Commentaire:
Texte supprimé. Texte ajouté.
Ligne 1: Ligne 1:
= Quelques exercices de programmation très standards = = Quelques exercices de programmation classiques =


== Échanger deux variables ==

Après :
{{{#!highlight python
a = 1
b = 'Ceci n’est pas un nombre.'
a = b
b = a
}}}
que valent `a` et `b` ?

Comment échanger les valeurs de deux variables ?

(Astuce : il en faut une troisième.)


== Tester l’appartenance ==

Écrivez une fonction :
{{{#!highlight python
def trouve(l,x):
 ...
}}}
qui renvoie `True` si `x` est un élément de la liste `l` et `False` sinon.

Testez :
{{{#!highlight python
l=[1,6,6,4]
trouve(l,0)
trouve(l,1)
trouve(l,6)
trouve(l,4)
trouve('Bonjour','B')
trouve('Bonjour','b')
}}}

Transformez légèrement la fonction pour qu’elle renvoie l’indice de
`x` dans `l` (le numéro de la « case » où `x` apparaît) au lieu de `True`.
Testez :
{{{#!highlight python
trouve(l,6)
trouve(l,6) == False
trouve(l,1)
trouve(l,1) == False
}}}
Argh ! Que s’est-il passé ? Le test d’égalité prend en fait en compte
des conversions possibles entre les types, et permet de considérer
que `False == 0` et `True == 1`. Donc `False` n’est pas un bon choix de valeur
d’erreur. On pourrait prendre `-1` par convention, mais seulement parce qu’on
sait qu’on attend un résultat positif. La manière « propre » de gérer ce cas,
c’est d’utiliser la constante `None`, de type `NoneType`, qui a la propriété
de n’être égale qu’à elle-même. Modifiez donc encore la fonction pour renvoyer
`None` plutôt que `False` dans le cas où on ne trouve pas l’élément.

== Ordre lexicographique ==

Lorsqu’on a une relation d’ordre total sur les éléments des listes (autrement dit, on peut
les comparer deux-à-deux), on peut définir l’ordre lexicographique sur les listes,
qui comme son nom l’indique est l’ordre du dictionnaire. Voir [[https://fr.wikipedia.org/wiki/Ordre_lexicographique|la page Wikipédia]] sur le sujet.

Écrivez une fonction
{{{#!highlight python
def compare_2(a,b):
 ...
}}}
telle que, en supposant que `a` et `b` sont des couples (des séquences de longueur 2)
renvoie `-1` si `a` est avant `b` dans l’ordre lexicographique, `1` si `b` est avant `a`
et `0` sinon (dans ce cas, `a == b`). On ne s’intéresse pas au comportement de la fonction
si `a` et `b` n’ont pas les bonnes longueurs.

Testez la fonction dans un peu tous les cas.

Écrivez maintenant une fonction
{{{#!highlight python
def compare_meme(a,b):
 ...
}}}
qui a le même comportement, en supposant cette fois seulement que `a` et `b` sont de même longueur
(mais cette longueur n’est pas fixée).

Testez. Attention au cas des séquences vides !

Terminez avec une fonction
{{{#!highlight python
def compare(a,b):
 ...
}}}
similaire aux précédentes, mais cette fois avec `a` et `b` de longueurs quelconques.
Testez.

== Renverser une chaîne ==

Écrivez une fonction :
{{{#!highlight python
def renverse(entree):
 ...
}}}
qui prend en argument une chaîne `entree` et renvoie la chaîne
renversée, c’est-à-dire que `renverse('abcde')` doit renvoyer (et pas afficher) `'edcba'`.

Rappelez-vous qu’il n’y a pas de manière naturelle en Python de dire quelque chose comme :
« on part avec un tableau vide de n cases », et surtout que les chaînes ne sont pas mutables.
Il faut donc ''construire'' le résultat.

Vérifiez que la fonction ``renverse`` peut aussi être utilisée de
la même manière sur les séquences (listes, n-uplets).


== Renverser une liste (en place) ==


Écrivez une ''procédure'' :
{{{#!highlight python
def retourne(entree):
 ...
}}}
qui prend en argument une liste `entree` et transforme cette liste pour que
l’ordre des éléments soit renversé. Autrement dit, il faut qu’après :
{{{#!highlight python
l = [1,2,3]
retourne(l)
}}}
`l` contienne `[3,2,1]`.

La réponse au tout premier exercice sera utile.

Vérifiez que la fonction ``renverse`` ''ne peut pas'' être utilisée de
la même manière sur les n-uplets et les chaînes.

Quelques exercices de programmation classiques

Échanger deux variables

Après :

   1 a = 1
   2 b = 'Ceci n’est pas un nombre.'
   3 a = b
   4 b = a

que valent a et b ?

Comment échanger les valeurs de deux variables ?

(Astuce : il en faut une troisième.)

Tester l’appartenance

Écrivez une fonction :

   1 def trouve(l,x):
   2         ...

qui renvoie True si x est un élément de la liste l et False sinon.

Testez :

   1 l=[1,6,6,4]
   2 trouve(l,0)
   3 trouve(l,1)
   4 trouve(l,6)
   5 trouve(l,4)
   6 trouve('Bonjour','B')
   7 trouve('Bonjour','b')

Transformez légèrement la fonction pour qu’elle renvoie l’indice de x dans l (le numéro de la « case » où x apparaît) au lieu de True. Testez :

   1 trouve(l,6)
   2 trouve(l,6) == False
   3 trouve(l,1)
   4 trouve(l,1) == False

Argh ! Que s’est-il passé ? Le test d’égalité prend en fait en compte des conversions possibles entre les types, et permet de considérer que False == 0 et True == 1. Donc False n’est pas un bon choix de valeur d’erreur. On pourrait prendre -1 par convention, mais seulement parce qu’on sait qu’on attend un résultat positif. La manière « propre » de gérer ce cas, c’est d’utiliser la constante None, de type NoneType, qui a la propriété de n’être égale qu’à elle-même. Modifiez donc encore la fonction pour renvoyer None plutôt que False dans le cas où on ne trouve pas l’élément.

Ordre lexicographique

Lorsqu’on a une relation d’ordre total sur les éléments des listes (autrement dit, on peut les comparer deux-à-deux), on peut définir l’ordre lexicographique sur les listes, qui comme son nom l’indique est l’ordre du dictionnaire. Voir la page Wikipédia sur le sujet.

Écrivez une fonction

   1 def compare_2(a,b):
   2         ...

telle que, en supposant que a et b sont des couples (des séquences de longueur 2) renvoie -1 si a est avant b dans l’ordre lexicographique, 1 si b est avant a et 0 sinon (dans ce cas, a == b). On ne s’intéresse pas au comportement de la fonction si a et b n’ont pas les bonnes longueurs.

Testez la fonction dans un peu tous les cas.

Écrivez maintenant une fonction

   1 def compare_meme(a,b):
   2         ...

qui a le même comportement, en supposant cette fois seulement que a et b sont de même longueur (mais cette longueur n’est pas fixée).

Testez. Attention au cas des séquences vides !

Terminez avec une fonction

   1 def compare(a,b):
   2         ...

similaire aux précédentes, mais cette fois avec a et b de longueurs quelconques. Testez.

Renverser une chaîne

Écrivez une fonction :

   1 def renverse(entree):
   2         ...

qui prend en argument une chaîne entree et renvoie la chaîne renversée, c’est-à-dire que renverse('abcde') doit renvoyer (et pas afficher) 'edcba'.

Rappelez-vous qu’il n’y a pas de manière naturelle en Python de dire quelque chose comme : « on part avec un tableau vide de n cases », et surtout que les chaînes ne sont pas mutables. Il faut donc construire le résultat.

Vérifiez que la fonction renverse peut aussi être utilisée de la même manière sur les séquences (listes, n-uplets).

Renverser une liste (en place)

Écrivez une procédure :

   1 def retourne(entree):
   2         ...

qui prend en argument une liste entree et transforme cette liste pour que l’ordre des éléments soit renversé. Autrement dit, il faut qu’après :

   1 l = [1,2,3]
   2 retourne(l)

l contienne [3,2,1].

La réponse au tout premier exercice sera utile.

Vérifiez que la fonction renverse ne peut pas être utilisée de la même manière sur les n-uplets et les chaînes.

WikISN: TPAlgoÉlémentaire (dernière édition le 2016-01-25 14:01:22 par LionelVaux)