Correction des exercices

ALG5 - F ONCTIONS ET EXEMPLES D ’ APPLICATION
if x<=z:
return x,z,y
else:
return z,x,y
8
9
É LEMENTS DE CORRECTION
ALG5 - F ONCTIONS ET EXEMPLES D ’ APPLICATION
10
11
else:
if x<=z:
return y,x,z
else:
if y<=z:
return y,z,x
else:
return z,y,x
12
13
14
Les corrections des exercices données ci-après ne sont que des indications pour aboutir à la solution, qui détaillent la plupart du temps un cheminement à suivre. D’autres solutions
15
sont possibles. . .
16
17
18
É LÉMENTS DE CORRECTION DE L’ EXERCICE N 1
O
19
On n’oubliera pas d’écrire les spécifications de la fonction.
1
2
3
4
5
6
7
8
9
10
11
12
(2). Les trois côtés a , b et c n’étant pas saisi nécessairement dans l’ordre, il faut les réordonner tout d’abord pour avoir la mesure
du plus grand côté de ce triangle.
Code Python
def compare_x_y(x,y):
""" A partir de deux réels x et y renverra:
* -1 si x<y
* 0 si x=y
* 1 sinon """
if x<y:
return -1
else:
if x>y:
return 1
else:
return 0
1
2
3
4
Code Python
def pythagore(a,b,c):
""" vérifie que le triangle donc les trois côtés
mesurent a, b et c est rectangle
Renverra Vrai si c’est le cas, Faux sinon """
5
print(type(ord_triplet(a,b,c)))
cote=ord_triplet(a,b,c)
if cote[2]**2==cote[1]**2+cote[0]**2:
return True
else:
return False
6
7
8
9
10
11
É LÉMENTS DE CORRECTION DE L’ EXERCICE N O 2
É LÉMENTS DE CORRECTION DE L’ EXERCICE N O 4
Lorsque l’on met en application l’algorithme des divisions successives, il est nécessaire de récupérer le valeurs des bits obtenus puis
de « retourner » leur affichage. On écrira donc une fonction qui « retourne » une chaîne de caractère.
Code Python
1
Code Python
1
2
3
4
5
6
2
def retourne_chaine(chaine):
""" Retourne une chaîne de caractères """
retourne=""
for i in range(0,len(chaine)):
retourne=retourne+chaine[len(chaine)-i-1]
return retourne
3
4
5
6
7
8
7
8
9
10
11
12
13
14
15
16
17
def ligne_sapin(n,d):
ligne=d+""
for i in range(n):
ligne=ligne+"^"
return ligne
9
def decomposition_en_binaire(n):
""" Renvoie la décomposition en binaire de l’entier
naturel n par la méthode des divisions successives """
N=n
i=0
S=""
while N!=0:
S=S+str(N%2)
N=N//2
return retourne_chaine(S)
10
11
def decalage(n):
d=""
for i in range(n):
d=d+" "
return d
12
13
14
15
16
17
18
19
def sapin(n):
nb_motif=1
decale=decalage(n+1)
for i in range(n):
print(ligne_sapin(nb_motif,decale))
nb_motif=nb_motif+2
decale=decalage(n-i)
20
21
sapin(12)
É LÉMENTS DE CORRECTION DE L’ EXERCICE N O 3
(1). On classe les trois nombres par ordre croissant en étudiant les différents cas :
1
2
3
4
5
6
7
É LÉMENTS DE CORRECTION DE L’ EXERCICE N O 5
Code Python
def ord_triplet(x,y,z):
""" Renvoie par ordre croissant les trois nombres
x,y,z saisis en paramètres """
if x<=y:
if y<=z:
return x,y,z
else:
I NFORMATIQUE - CPGE MPSI - 2016/17
(1). Il suffit de faire calculer le reste de la division euclidienne de n par 10 :
1
2
3
1
Code Python
def unite(n):
""" Renvoie le chiffre des unités de l’entier n"""
return n\%10
É LÉMENTS DE CORRECTION CHAPITRE ALG5
(2). Cette fonction renvoie le chiffre des dizaines de n , et on devrait donc l’appeller dizaine.
(3). On s’inspire des deux fonctions précédentes.
1
2
3
4
Code Python
def centaine(n):
""" Renvoie le chiffre des centaines de l’entier n"""
a=n//100
return(unite(a))
(4). Ici :
1
2
3
4
Code Python
def Armstrong(n):
for i in range(m):
if unite(i)**3+dizaine(i)**3+centaine(i)**3==i:
print(i)
On pourrait utiliser une liste pour stocker ces nombres et la renvoyer en résultat de la fonction Armstrong.
É LÉMENTS DE CORRECTION DE L’ EXERCICE N O 6
1
2
3
4
5
6
7
8
Code Python
def palyndrome(mot):
mot_retourne=""
for i in range(len(mot)):
mot_retourne=mot_retourne+mot[len(mot)-i-1]
if mot==mot_retourne:
return True
else:
return False
9
10
11
print(palyndrome("toto"))
print(palyndrome("sos"))
I NFORMATIQUE - CPGE MPSI - 2016/17
2
É LÉMENTS DE CORRECTION CHAPITRE ALG5