Srie dexercices N2

Programmation Python
Exercice 1.
crire un programme qui permet de saisir le nom de l'utilisateur et dafficher "Bonjour", suivi de ce nom.
Exercice 2.
Ecrire un programme qui permet de saisir un entier tant que la valeur entre ne peut tre convertie en entier.
(Indication : utiliser la mthode isdigit() qui permet de vrifier si une chane contient que des caractres
chiffres ou non)
Exercice 3.
Ecrire un programme qui calcule la somme des chiffres dun entier positif.
Exercice 4.
Ecrire un programme quaffiche n tel que n soit le premier entier qui vrifie 2n > k. Ce programme lit lentre
k au clavier. On prcise quen langage Python, 2**n signifie 2 la puissance n.
Exercice 5.
On considre deux listes dentiers. La premire est infrieure la seconde si lune des deux conditions
suivantes est vrifie :
les n premiers nombres sont gaux mais la premire liste ne contient que n lments tandis que la
seconde est plus longue
les n premiers nombres sont gaux mais que le n + 1me de la premire liste est infrieur au n + 1me
de la seconde liste
Par consquent, si l est la longueur de la liste la plus courte, comparer ces deux listes dentiers revient
parcourir tous les indices depuis 0 jusqu l exclu et sarrter sur la premire diffrence qui dtermine le
rsultat. Sil ny pas de diffrence, alors la liste la plus courte est la premire.
Il faut crire une fonction compare_liste(p, q) qui implmente cet algorithme.
Exercice 6.
Ecrire un programme qui calcule llment u13 de la suite dfinie par :
u1 = 1
u2 = 2
n > 2; un = un-1 + un-2
Exercice 7. fonctions et procdures
On dsire crer un glossaire des mots techniques dinformatique. Pour cela on utilisera un une chane de
caractres Glossaire, dans lequel on stockera les mots techniques. Tous les mots, sauf le dernier, sont suivit
par le caractre :.
o r d i n a t e u r : s o u r i
s
a) Ecrire la fonction AjoutMot(Glossaire ) qui lit un mot au clavier et lajoute au glossaire la nouvelle chane
doit tre retourner.
b) Ecrire la fonction NombreMot(Glossaire) qui calcul et retourne le nombre de mots contenu dans la chane.
c) Ecrire la procdure AfficheListeMot(Glossaire ) qui affiche la liste de tous les mots du glossaire
d) Ecrire la fonction dont la signature est : chercheMot(Glossaire , Mot) qui retourne 1 si le mot Mot existe
dans le Glossaire et 0 sinon.
e) Ecrire la fonction iemeMot(Glossaire , i) qui affiche le ime mot du glossaire sil existe et affiche : indice
hors limite sinon.
f) Ecrire la fonction existeDoublon(Glossaire) qui cherche lexistence des mots en double.
g) Ecrire la fonction supprimeMot(Glossaire) qui supprime un mot du glossaire dont on prcisera la
position.
e) Ecrire une fonction qui permet de crer une liste contenant tous les mots techniques contenant dans le
Glossaire GlossaireToListe(Glossaire)
f. Plus difficile : crire une fonction triGlossaire(Glossaire) qui classe tout les mots du glossaire par ordre
alphabtique croissant.

Exercice 8
La notation habituelle des expression algbriques, sous forme dite infixe, o les oprateurs +, -, *, / figurant
entre leurs 2 oprandes, souffre a priori dune ambigut si lon nintroduit pas des priorits entres les
oprateurs. Cest ainsi que la notation 2+3*4 peut aussi bien dsigner 2+(3*4)=14 que (2+3)*4=20.
Des parenthses ou des rgles de priorit sont donc ncessaire pour lever cette ambigut. Nous allons tudier
ici une autre notation, appele notation algbrique poste-fixe ou encoure notation polonaise inverse qui ne
souffre pas de ces inconvnients. Cette notion est utilise par certains langages de programmations ou
certaines calculatrices.
Exemple
2 3 + sin 4 * 5 6 + Son quivalent en notation infixe : (sin(2+3)*4)-(5+6)
Les tapes de son valuation :
+ oprateur binaire r=2+3
sin un seul paramtre r=sin(r)
* oprateur binaire r=r*4
+ oprateur binaire s=5+6
- oprateur binaire r=r-s
On suppose dans ce problme une expression algbrique sous forme dune chane de caractre C compose
de : 4 oprateurs +, -, *, / des oprandes caractres appartenant lensemble des entiers {exemple
"10","231", "2", "1759"} reprsentant des entiers positifs.
La transformation dun caractre chiffre 0<=C[i]<9 en entier quivalent se fait par la soustraction du
caractre 0 de c[i] (ex. 1-0 = 1).
Des tapes de lvaluation, on remarque que les oprandes de s sont mmorises puis values par les
oprateurs de s suivant le principe LIFO (Last In First Out) implment par une structure stack (liste dans
notre cas).
Exemple "1 2 +"
(le dernier caractre soulign est le caractre courant)
12+

12+

12+
a

2
1

b
2
1

a+b
1

On supposant que lexpression s est rdige correctement selon la notation algbrique poste-fixe.
Ecrire la fonction eval(s) qui donne la valeur de lexpression algbrique C.
Solution
1)
Nom=input(donner votre nom)
print(Bonjour,Nom)
2)
N=input(donner un entier)
while(N.isdigit()==False)
N=input(donner un entier)
N=int(N)
3)
def somme (n) :
return sum ( [ int (c) for c in str (n) ] )

Cette criture rsume cache une conversion en chane de caractres. Une boucle est invitable moins de
procder par rcurrence. Commenons par une version plus tendue et qui passe par les chanes de caractres.
Pour cette version, il ne faut pas oublier de faire la conversion inverse, cest--dire celle dun caractre en
nombre.
def somme (n) :
l = str (n) # il ne faut pas confondre l=str (n) avec l = "n"
s=0
for c in l : # ou for i in range (0, len (c)) :
s += int (c) # ou s += int (c [i])
return s
Une version numrique maintenant, celle qui utilise lopration % ou modulo pour obtenir le dernier chiffre
def somme (n) :
s=0
while n > 0 :
s += n % 10
n /= 10 # ici, cest une division entire, si vous ntes pas sr :
# n = int (n/10)
return n
Enfin, une autre solution utilisant la rcurrence et sans oublier la condition darrt
def somme (n) :
if n <= 0 : return 0
else : return (n % 10) + somme ( n / 10 )
4)
def fonction_log2 (k) :
n=0
while 2**n < k :
n += 1
return n
5)
Version 1
def compare_liste (p,q) :
i=0
while i < len (p) and i < len (q) :
if p [i] < q [i] : return -1 # on peut dcider
elif p [i] > q [i] : return 1 # on peut dcider
i += 1 # on ne peut pas dcider
# fin de la boucle, il faut dcider partir des longueurs des listes
if len (p) < len (q) : return -1
elif len (p) > len (q) : return 1
else : return 0
On pourrait galement crire cette fonction avec la fonction cmp qui permet de comparer deux lments quels
quils soient.
Version 2
def compare_liste (p,q) :
i=0
while i < len (p) and i < len (q) :
c = cmp (p [i], q [i])
if c != 0 : return c # on peut dcider
i += 1 # on ne peut pas dcider
# fin de la boucle, il faut dcider partir des longueurs des listes
return cmp (len (p), len (q))
6)
def Fibonacci (n) :

if n == 2 : return 2
elif n == 1 : return 1
else : return Fibonacci (n-1) + Fibonacci (n-2)
print Fibonacci (13)
Cette solution nest pas trs rapide car si Fibonacci (13) va tre appele une fois, Fibonacci (12) une
fois aussi, mais Fibonacci (11) va tre appele deux fois... Cette solution implique un grand nombre de
calculs inutiles.
Aprs la solution rcursive descendante (n dcrot), la solution rcursive montante (n crot) :
version 2
def Fibonacci (fin, n = 2, u1 = 1, u2 = 2) :
if fin == 1 : return u1
elif fin == 2 : return u2
elif n == fin : return u2
u = u1 + u2
return Fibonacci (fin, n+1, u2, u)
print Fibonacci (13)
La mthode la plus simple est non rcursive mais il ne faut pas se tromper dans les indices :
def Fibonacci (n) :
if n == 1 : return 1
u1 = 1
u2 = 2
for i in range (3,n+1) :
u = u1 + u2 # il est impossible de
u1 = u2 # rsumer ces trois lignes
u2 = u # en deux
return u2
print Fibonacci (13)
Quelques variantes utilisant les listes
def Fibonacci (n) :
if n == 1 : return 1
u = [1,2]
for i in range (2,n) :
u.append (u [i-1] + u [i-2])
return u [n-1]
print Fibonacci (12)