Transcript Informatique en CPGE (2014-2015) Devoir surveillé 1

http://mathematice.fr
Informatique en CPGE (2014-2015)
Devoir surveillé 1
Exercice 1 (6 pts)
1. On considère le code Python de la fonction d suivante :
def d(n):
L=[1]
for nombre in range(2,n+1):
if n%nombre==0:
L.append(nombre)
return L
Quel est le résultat de l’appel d(4) ? Puis de l’appel d(10) ?
Que fait la fonction d ?
2. Un diviseur non-trivial d’un entier n est un diviseur de n différent de 1 et de n. Ecrire une fonction
DNT, d’argument n, renvoyant la liste des diviseurs non-triviaux de l’entier n.
3. Ecrire une fonction sommeCarresDNT, d’argument n, renvoyant la somme des carrés des diviseurs
non-triviaux de l’entier n.
Quel est le résultat de l’appel sommeCarresDNT(4) ? Puis de l’appel sommeCarresDNT(9) ? Puis
de l’appel sommeCarresDNT(16) ? Puis de l’appel sommeCarresDNT(25) ?
4. Ecrire la suite des instructions permettant d’afficher tous les nombres entiers inférieurs à 1000 et
égaux à la somme des carrés de leurs diviseurs non-triviaux. Peut-on prévoir le résultat ?
Exercice 2 (7pts)
On considère un rationnel x ∈]0; 1[. On note x = ab avec b ≥ 2 et 0 < a < b. On s’intéresse au
problème suivant : peut-on trouver des entiers a1 , a2 , . . . an tels que 2 ≤ a1 < a2 < . . . < an de telle sorte
que :
1
1
1
x=
+
+ ... +
?
a1 a2
an
Par exemple, on a
3
8
=
1
3
+
1
24
.
On considère le programme suivant :
def decompose(a,b):
res=[]
r=b%a
q=b//a
while r!=0:
res.append(q+1)
a=a-r
b=b*(q+1)
r=b%a
q=b//a
res.append(q)
return res
a=int(input(’Entrer la valeur du numérateur a : ’))
b=int(input(’Entrer la valeur du dénominateur b : ’))
print(decompose(a,b))
Serge Bays
1
Lycée Les Eucalyptus
http://mathematice.fr
Rappel : b//a et b%a donnent respectivement le quotient et le reste dans la division euclidienne de b
par a.
1. Donner un exemple de quotient
a
b
pour lequel il n’y aura pas de passage dans la boucle "while".
5
8 (donc
fraction 37 .
2. Détailler l’exécution de ce programme sur la fraction
3. Détailler l’exécution de ce programme sur la
si on entre les valeurs a = 5 et b = 8).
4. Prouver que le programme est correct.
5. Prouver que le programme se termine.
6. On note, pour n ≥ 1 et k ≥ 1, αn = n! + 1 et βk,n = k(n!) + 1.
(a) Ecrire la division euclidienne de βk,n par n. (On pourra distinguer les cas n = 1 et n 6= 1.)
(b) Prouver que l’exécution de la fonction sur a = n et b = βk,n renvoie une liste de longueur n.
(c) En déduire que la décomposition renvoyée pour a = n et b = αn est de longueur n.
7. Combien d’opérations sont effectuées à chaque passage dans la boucle "while" ? En déduire un
majorant (fonction de a et b) du nombre d’opérations effectuées par le programme.
Exercice 3 (7 pts)
Il s’agit de simuler un jeu de cartes très simple à deux joueurs (joueur1 et joueur2). Les 32 cartes sont
numérotées de 1 à 32 et sont donc toutes différentes.
On commence par répartir ces 32 cartes de manière aléatoire en deux paquets de 16 cartes.
Ensuite le jeu se déroule de la manière suivante : chaque joueur retourne la carte sur le dessus de son
paquet ; celui qui a la plus grande carte gagne le coup. Il place alors les deux cartes, la sienne et celle de
son adversaire, sous le paquet, la plus petite étant sous la plus grande.
Lorsqu’un joueur n’a plus de carte, il est le perdant et le jeu s’arrête.
Afin d’utiliser la structure de pile, on suppose données les fonctions creer_pile(c), qui permet de
créer une pile de capacité c, empiler(p,x) qui empile un élément x sur la pile p, depiler(p) qui enlève
l’élément sur le dessus de la pile p et le renvoie, pile_vide(p), qui renvoie True si la pile p est vide et False
sinon, et taille(p) qui renvoie la taille de la pile p.
La fonction randint(a,b) du module random renvoie un entier aléatoire entre a et b, bornes comprises.
1. Ecrire un code permettant de créer la variable jeu de type list qui a pour valeur la liste [1,2,3,. . . ,32].
Bien entendu, il ne s’agit pas d’écrire : jeu =[1,2,3,. . . ,32] !
2. Constitution des deux paquets de 16 cartes.
Expliquer chaque ligne de la fonction distrib(jeu) écrite ci-dessous.
def distrib(jeu):
p=creer_pile(32)
for i in range(16):
n=randint(1,len(jeu))
k=jeu.pop(n-1)
empiler(p,k)
return p
Après l’instruction pile1=distrib(jeu), que contiennent les variable pile1 et jeu ?
3. Ecrire une fonction gagne qui prend en argument une pile p et deux nombres a et b avec a > b. La
fonction place les deux nombres au fond de la pile p, ("sous le paquet"), avec a au dessus de b et
renvoie la pile p. Pour cela on pourra créer une pile temporaire.
4. Ecrire une fonction joue() qui ne prend aucun argument. La fonction crée les deux "paquets" pile1
et pile2 puis, tant que les piles ne sont pas vides, simule un coup comme décrit plus haut en utilisant
la fonction gagne.
La fonction ne renvoie rien mais affiche un message disant quel joueur a gagné.
Serge Bays
2
Lycée Les Eucalyptus