Algorithmique et programmation

B. range la valeur 7 dans la variable x — Le signe = est celui de l’affectation : il range la valeur de droite dans la variable de gauche. Le test d’égalité s’écrit ==.

D. 3, 4, 5, 6, 7, 8 — La première borne est incluse, la seconde exclue : range(3, 9) s’arrête à 8 et fait 9 − 3 = 6 tours.

A. % — % donne le reste, // le quotient entier, / la division décimale et ** la puissance. Ainsi 17 % 5 vaut 2.

C. def — On écrit def, le nom, les paramètres entre parenthèses et deux-points. return s’écrit à l’intérieur, pour renvoyer la valeur.

D. les entiers de 1 à 6 — Avec randint, les deux bornes sont comprises : le résultat est un entier de 1 à 6. C’est random() qui renvoie un flottant de [0 ; 1[.

B. 12 — Le membre de droite est calculé avec l’ancienne valeur : 3 × 4 = 12, qui remplace 4. Ce n’est pas une égalité à résoudre, et * multiplie les nombres.

C. 5 — range(5) parcourt 0, 1, 2, 3 et 4 : cela fait 5 valeurs, donc 5 tours, même si 5 n’est jamais atteint.

A. afficher une valeur à l’écran — print affiche, sans rien renvoyer. Pour qu’une fonction fournisse une valeur utilisable dans un calcul, on écrit return.

B. str — str désigne les chaînes de caractères ; int les entiers, float les flottants et bool les booléens True et False.

D. sa condition devient fausse — while répète son bloc tant que la condition est vraie : elle s’arrête dès que la condition est fausse.

C. a ← 3 — La flèche ← note l’affectation en langage naturel ; en Python, on écrit a = 3. Le double égal == est un test.

A. un flottant de [0 ; 1[ — random() renvoie un nombre à virgule au hasard, supérieur ou égal à 0 et strictement inférieur à 1 : la borne 1 est exclue.

C. 20 — k prend les valeurs 1, 2, 3 et 4 : on ajoute 2, 4, 6 puis 8, et la somme vaut 20.

A. 25 — t prend les valeurs 100, 75, 50 puis 25. Comme 25 > 30 est faux, la boucle s’arrête : t vaut 25.

D. 7 — h(5) = 3 × 5 − 4 = 11 et h(0) = −4 : la somme vaut 11 + (−4) = 7.

B. 6 — La boucle extérieure fait 3 tours et, pour chacun, la boucle intérieure en fait 2 : 3 × 2 = 6 affichages.

B. 24 — On multiplie par 1, 2, 3 puis 4 : p vaut 24. Un produit s’initialise à 1 ; avec p = 0 au départ, il resterait nul.

D. 4 et 1 — 9 = 2 × 4 + 1 : le quotient entier est 4 et le reste est 1. C’est 9 / 2 qui vaudrait 4,5.

A. while p <= 5000: — On continue tant que le seuil n’est pas dépassé, c’est-à-dire tant que p ≤ 5 000 : la condition du while est le contraire de la condition d’arrêt p > 5 000.

C. −17 — Les arguments sont pris dans l’ordre : a = 3 et b = 10, donc 3 − 2 × 10 = −17. f(10, 3) vaudrait 4.

A. n % 3 == 0 and 10 <= n <= 50 — Les deux conditions doivent être vraies en même temps : and. Le reste se teste avec % et l’égalité avec == ; un seul signe = provoquerait une erreur.

D. 42 — int convertit la chaîne tapée en l’entier 41, et 41 + 1 = 42. Sans int, n + 1 provoquerait une erreur.

B. 6 — k vaut 2, 5, 8, 11, 14 et 17 ; la valeur suivante, 20, est la borne exclue : 6 tours.

C. c / n — La fréquence est le nombre de succès divisé par le nombre de répétitions : c / n, un nombre entre 0 et 1.

D. n vaut 1, puis while n != 20: n = n + 6 — Avec n = n + 6, n prend les valeurs 1, 7, 13, 19, 25… : il saute par-dessus 20, la condition n != 20 reste vraie. Les trois autres boucles atteignent leur condition d’arrêt.

B. les flottants sont codés de façon approchée — La machine code les flottants avec un nombre fini de chiffres binaires : la somme diffère de 0,3 d’une quantité infime. On compare donc des flottants avec une inégalité.

C. sans return, f(4) vaut None — La fonction affiche 8 mais ne renvoie rien : f(4) vaut None, et None + 1 est impossible. Il faut écrire return 2 * x.

A. 10, 8, 6, 4, 2 — On part de 10, on avance de −2 en −2, et la borne 0 est exclue : on s’arrête à 2. Cela fait 5 valeurs.

C. compte : seul le premier test vrai est exécuté — Dès qu’un test est vrai, son bloc est exécuté et les suivants sont ignorés : on place la condition la plus restrictive en premier.

A. c’est normal, la fréquence fluctue — La fréquence observée sur un échantillon varie d’une simulation à l’autre autour de la probabilité : un écart de 0,02 sur 500 tirages n’a rien d’anormal.

D. 1, 3, 6 puis 10 — Le print est indenté dans la boucle : il s’exécute à chaque tour et affiche les sommes partielles 1, 3, 6 puis 10. Aligné sur le for, il n’afficherait que 10.

B. for i in range(101): x = i / 100 — range n’accepte que des entiers. On parcourt les entiers de 0 à 100 et l’on divise par 100 pour obtenir les valeurs décimales voulues.

B. 4 — k parcourt 0, 1, 2, 3, 4 et seuls les impairs sont ajoutés : 1 + 3 = 4. On trouverait 9 si k allait jusqu’à 5.

C. 0 — Les deux tests sont faux pour x = 0 : on arrive à la dernière ligne, qui renvoie 0. Les return précédents ne sont pas exécutés.

A. 5 — b a été calculée quand a valait 3 : b = 5. Changer a ensuite ne modifie pas b, qui garde sa valeur.

D. randint(0, 1) — randint(0, 1) renvoie 0 ou 1 avec la même probabilité. randint(0, 2) a trois issues, random() < 1 est toujours vrai et randint(1, 2) == 3 toujours faux.