$course$/QCM de maths/Seconde/Algorithmique et programmation Types de variables (entier, flottant, chaîne de caractères),
affectation et séquence d'instructions, instruction conditionnelle,
boucles bornées et non bornées, fonctions : écrire, lire, compléter
et appeler. Programmes en Python ou en langage naturel.

]]> Algorithmique et programmation — Q01 : Le type d'une valeur entre guillemets Après l'instruction a = "12", quel est le type de la variable a ?

]]> En Python, le type se lit sur l'écriture de la valeur : 12 est un
entier (int), 12.0 un flottant (float), "12" une chaîne de
caractères (str).

]]> 1.0 0.0 0 true true abc Un flottant, le nombre 12{,}0

]]> Erreur : un flottant s'écrit avec un point, comme 12.0, et
sans guillemets.

]]> Un booléen, vrai ou faux

]]> Erreur : un booléen ne prend que les valeurs True et False.

]]> Une chaîne de caractères

]]> Bonne réponse : les guillemets signalent un texte. La variable
contient les caractères « 1 » et « 2 », pas le nombre douze.

]]> Un entier, le nombre douze

]]> Erreur : sans les guillemets, a = 12 serait bien un entier.
Les guillemets transforment la valeur en texte.

]]> Algorithmique et programmation — Q02 : Le type d'un quotient Après l'instruction m = 7 / 2, quel est le type de m ?

]]> 7 / 2 vaut 3.5 (flottant), 7 // 2 vaut 3 (quotient entier)
et 7 % 2 vaut 1 (reste de la division euclidienne).

]]> 1.0 0.0 0 true true abc Cela dépend des valeurs

]]> Erreur : avec /, le résultat est un flottant quelles que
soient les valeurs, même lorsque la division tombe juste.

]]> Une chaîne

]]> Erreur : aucun guillemet n'apparaît, le résultat est un nombre.

]]> Un entier

]]> Erreur : même 8 / 2 donne 4.0, un flottant. Le quotient
entier s'obtient avec //.

]]> Un flottant

]]> Bonne réponse : l'opérateur / renvoie toujours un flottant.
Ici m vaut 3.5.

]]> Algorithmique et programmation — Q03 : Suivre deux affectations Quelle est la valeur de x après l'exécution de ces instructions ?

`python x = 5 x = x + 3 x = 2 * x`

]]> Une affectation x = expression calcule d'abord l'expression avec
la valeur actuelle de x, puis range le résultat dans x. On suit
le programme ligne par ligne.

]]> 1.0 0.0 0 true true abc 10

]]> Erreur : la deuxième ligne a été oubliée. Elle modifie x avant
le doublement.

]]> 16

]]> Bonne réponse : x vaut d'abord 5, puis 5 + 3,
puis le double de ce résultat, soit 16.

]]> 8

]]> Erreur : la dernière ligne a été oubliée. La valeur de x est
encore doublée.

]]> 13

]]> Erreur d'ordre : les instructions s'exécutent de haut en bas.
On ajoute 3 avant de doubler.

]]> Algorithmique et programmation — Q04 : Échanger deux variables On veut échanger les contenus des variables a et b. Quelle
séquence d'instructions convient ?

]]> Une affectation remplace l'ancienne valeur. Pour échanger deux
contenus, il faut une variable auxiliaire qui conserve l'une des
deux valeurs.

]]> 1.0 0.0 0 true true abc b = a, puis a = b

]]> Erreur : même défaut dans l'autre sens. Les deux variables
finissent avec la valeur initiale de a.

]]> c = a, puis a = b, puis b = c

]]> Bonne réponse : la variable c garde une copie de l'ancienne
valeur de a avant qu'elle soit écrasée.

]]> a = b, puis b = a

]]> Erreur : après a = b, l'ancienne valeur de a est perdue.
Les deux variables finissent avec la valeur de b.

]]> c = a, puis b = c, puis a = b

]]> Erreur : b reçoit l'ancienne valeur de a, puis a reçoit
cette même valeur. L'ancienne valeur de b est perdue.

]]> Algorithmique et programmation — Q05 : Traduire une formule en Python On connaît le rayon r et la hauteur h d'un cylindre. Quelle
instruction range son volume V = π r² h dans la variable V ?
On suppose que pi contient une valeur approchée de π.

]]> Une affectation s'écrit variable = expression. Dans l'expression,
les produits s'écrivent et les puissances *.

]]> 1.0 0.0 0 true true abc V = pi r² h

]]> Erreur : Python n'accepte ni la multiplication sous-entendue ni
l'exposant écrit en petit : chaque opération doit être écrite.

]]> pi r 2 h = V

]]> Erreur : la variable qui reçoit la valeur s'écrit à gauche du
signe d'affectation, jamais à droite.

]]> V = pi r 2 h

]]> Bonne réponse : * est l'opérateur de puissance, et chaque
produit s'écrit avec .

]]> V = pi r ^ 2 h

]]> Erreur : en Python, ^ n'est pas la puissance. La puissance
s'écrit **.

]]> Algorithmique et programmation — Q06 : Additionner une saisie Un programme contient n = input("Nombre ? "). L'utilisateur tape
5. Pourquoi l'instruction n + 1 provoque-t-elle une erreur ?

]]> input renvoie une chaîne de caractères. Pour calculer, on la
convertit avec int (entier) ou float (flottant).

]]> 1.0 0.0 0 true true abc n contient le texte "5", pas un nombre

]]> Bonne réponse : input renvoie toujours du texte. On écrit
n = int(input("Nombre ? ")) pour obtenir un entier.

]]> n est vide tant que le programme n'est pas relancé

]]> Erreur : la saisie est bien rangée dans n, mais sous forme de
texte.

]]> n contient le flottant 5.0, incompatible avec 1

]]> Erreur : un flottant s'additionne sans difficulté à un entier.
Le problème vient du type chaîne.

]]> Le nombre 1 doit s'écrire 1.0

]]> Erreur : le type du nombre ajouté n'est pas en cause. On ne peut
pas ajouter un nombre à une chaîne de caractères.

]]> Algorithmique et programmation — Q07 : Quotient et reste en Python Que valent 17 // 5 et 17 % 5 ?

]]> Division euclidienne : a // b est le quotient entier et a % b
le reste, avec a == b * (a // b) + a % b.

]]> 1.0 0.0 0 true true abc 3 et 2

]]> Bonne réponse : 17 = 5 × 3 + 2 avec
0 ≤ 2 < 5 : // donne le quotient, % le reste.

]]> 3 et 0

]]> Erreur : % ne donne 0 que lorsque la division tombe juste,
ce qui n'est pas le cas ici.

]]> 17 et 5

]]> Erreur : ces opérateurs effectuent la division euclidienne de
17 par 5.

]]> 2 et 3

]]> Erreur : les rôles sont inversés. // donne le quotient
entier, % donne le reste.

]]> Algorithmique et programmation — Q08 : Une affectation en langage naturel Dans un algorithme en langage naturel, que signifie l'instruction
u ← u + 3 ?

]]> La flèche ← note l'affectation dans un algorithme en
langage naturel ; elle correspond au signe = de Python.

]]> 1.0 0.0 0 true true abc On compare u et u + 3

]]> Erreur : une comparaison ne modifie aucune variable. La flèche
modifie la valeur de u.

]]> Une équation d'inconnue u, sans solution

]]> Erreur : la flèche désigne une affectation, pas une égalité à
résoudre.

]]> La valeur de u augmente de 3

]]> Bonne réponse : on calcule u + 3 avec la valeur actuelle de
u, puis on range le résultat dans u.

]]> La variable u prend la valeur 3

]]> Erreur : ce serait u ← 3. Ici, on ajoute 3 à la
valeur déjà présente.

]]> Algorithmique et programmation — Q09 : Suivre un test Quelle valeur le programme suivant affiche-t-il ?

`python x = 7 if x > 5: y = 2 * x else: y = x + 1 print(y)`

]]> Avec if … else, exactement un bloc s'exécute : celui du if si la
condition est vraie, celui du else sinon.

]]> 1.0 0.0 0 true true abc Les deux valeurs 14 et 8

]]> Erreur : un seul des deux blocs s'exécute, jamais les deux.

]]> 8

]]> Erreur : c'est le calcul de l'autre bloc. La condition
x > 5 décide du bloc exécuté.

]]> 7

]]> Erreur : le programme affiche y, qui a été calculé à partir
de x, pas x lui-même.

]]> 14

]]> Bonne réponse : on compare 7 à 5 pour savoir quel bloc
s'exécute, puis on applique le seul calcul de ce bloc.

]]> Algorithmique et programmation — Q10 : Tester une égalité Quelle condition teste si la variable n vaut 0 ?

]]> Comparaisons en Python : == (égal), != (différent), <, <=,
>, >=. Le signe = seul réalise une affectation.

]]> 1.0 0.0 0 true true abc n == 0

]]> Bonne réponse : le double signe == compare deux valeurs et
donne True ou False.

]]> n = 0

]]> Erreur : un seul signe = est une affectation. Il range 0
dans n au lieu de le comparer.

]]> n != 0

]]> Erreur : != teste la différence. Cette condition est vraie
quand n ne vaut pas 0.

]]> n => 0

]]> Erreur : cette écriture n'existe pas en Python. « Supérieur ou
égal » s'écrit >=, et ce n'est pas un test d'égalité.

]]> Algorithmique et programmation — Q11 : Tester la parité Quelle condition est vraie exactement lorsque l'entier n est
pair ?

]]> L'entier n est multiple de d lorsque n % d == 0. Pour la
parité, on prend d = 2.

]]> 1.0 0.0 0 true true abc n % 2 == 0

]]> Bonne réponse : un entier est pair lorsque le reste de sa
division par 2 est nul.

]]> n // 2 == 0

]]> Erreur : le quotient entier n // 2 vaut 0 pour n = 0 ou
n = 1 seulement.

]]> n % 2 == 1

]]> Erreur : un reste égal à 1 caractérise les entiers
impairs.

]]> n / 2 == 0

]]> Erreur : n / 2 vaut 0 seulement si n vaut 0. C'est le
reste qu'il faut tester.

]]> Algorithmique et programmation — Q12 : Trois cas avec elif Qu'affiche ce programme ?

`python note = 14 if note >= 16: print("TB") elif note >= 12: print("B") else: print("P")`

]]> if … elif … else examine les conditions dans l'ordre et exécute
seulement le bloc de la première condition vraie.

]]> 1.0 0.0 0 true true abc TB

]]> Erreur : 14 n'est pas supérieur ou égal à 16, la première
condition est fausse.

]]> B puis P

]]> Erreur : dès qu'une condition est vraie, les blocs suivants sont
ignorés. Le else ne s'exécute pas.

]]> P

]]> Erreur : le else ne s'exécute que si toutes les conditions
précédentes sont fausses, or 14 ≥ 12.

]]> B

]]> Bonne réponse : 14 ≥ 16 est faux, 14 ≥ 12 est vrai :
le bloc du elif s'exécute, puis le test s'arrête.

]]> Algorithmique et programmation — Q13 : Appartenir à un intervalle Quelle condition est vraie exactement lorsque le nombre x
appartient à l'intervalle [2 ; 5[ ?

]]> x ∈ [a ; b[ se traduit par x >= a and x < b : un crochet
fermé donne une inégalité large, un crochet ouvert une inégalité
stricte.

]]> 1.0 0.0 0 true true abc x >= 2 and x < 5

]]> Bonne réponse : les deux inégalités doivent être vraies en même
temps, d'où and. La borne 2 est incluse, la borne 5
exclue.

]]> x >= 2 and x <= 5

]]> Erreur : cette condition accepte x = 5, alors que le crochet
de droite est ouvert.

]]> x > 2 and x <= 5

]]> Erreur : cette condition traduit ]2 ; 5]. Les crochets sont
inversés.

]]> x >= 2 or x < 5

]]> Erreur : avec or, une seule inégalité suffit. Tout réel
vérifie alors la condition, par exemple x = 100.

]]> Algorithmique et programmation — Q14 : Compléter un test d'alignement La fonction suivante doit renvoyer True lorsque les points
A(x_A ; y_A), B(x_B ; y_B) et C(x_C ; y_C) sont
alignés, les abscisses x_A, x_B et x_C étant distinctes.
Quelle condition compléter ?

`python def alignes(xA, yA, xB, yB, xC, yC): m1 = (yB - yA) / (xB - xA) m2 = (yC - yA) / (xC - xA) return ...`

]]> Trois points d'abscisses distinctes sont alignés lorsque les
coefficients directeurs de (AB) et de (AC) sont égaux. Avec des
flottants, l'égalité peut échouer à cause des arrondis : on compare
alors l'écart à une petite tolérance.

]]> 1.0 0.0 0 true true abc m1 == 0 and m2 == 0

]]> Erreur : cette condition ne reconnaît que les points alignés sur
une droite horizontale.

]]> m1 * m2 == -1

]]> Erreur : cette condition caractérise deux droites
perpendiculaires dans un repère orthonormé, pas l'alignement.

]]> m1 == m2

]]> Bonne réponse : les droites (AB) et (AC) ont un point
commun ; elles sont confondues si et seulement si elles ont le
même coefficient directeur.

]]> m1 + m2 == 0

]]> Erreur : des coefficients opposés donnent des droites
symétriques, pas confondues.

]]> Algorithmique et programmation — Q15 : Combien de tours de boucle Combien de fois le corps de la boucle for i in range(10):
est-il exécuté ?

]]> range(n) produit les entiers de 0 à n - 1, soit n valeurs ;
range(a, b) produit les entiers de a à b - 1.

]]> 1.0 0.0 0 true true abc Tant que i est inférieur à 10, sans fin

]]> Erreur : une boucle for sur range est bornée : son nombre de
tours est connu à l'avance.

]]> 9 fois

]]> Erreur : range(10) commence à 0. Les valeurs de 0 à 9
sont au nombre de 10.

]]> 11 fois

]]> Erreur : la borne 10 est exclue. La dernière valeur de i
est 9.

]]> 10 fois

]]> Bonne réponse : i prend les valeurs 0, 1, …, 9, soit
10 valeurs.

]]> Algorithmique et programmation — Q16 : Une somme calculée par une boucle Qu'affiche ce programme ?

`python s = 0 for k in range(1, 5 + 1): s = s + k print(s)`

]]> Motif de l'accumulateur : initialiser s = 0 avant la boucle, puis
ajouter à chaque tour. range(1, n + 1) parcourt les entiers de
1 à n.

]]> 1.0 0.0 0 true true abc 15

]]> Bonne réponse : la boucle ajoute les entiers de 1 à 5 :
1 + 2 + ⋯ + 5 = 15.

]]> 10

]]> Erreur : la borne 5 + 1 est exclue, mais 5 est bien
ajouté. La somme s'arrête à 5, pas à 5 - 1.

]]> 5

]]> Erreur : s accumule les valeurs successives de k, elle ne
garde pas seulement la dernière.

]]> 21

]]> Erreur : la valeur 5 + 1 n'est jamais prise par k, car la
borne de droite de range est exclue.

]]> Algorithmique et programmation — Q17 : Une boucle tant que Qu'affiche ce programme ?

`python n = 1 while n < 50: n = 3 * n print(n)`

]]> Une boucle while répète son corps tant que la condition est vraie.
À la sortie, la condition est fausse : ici, n est la première
puissance de 3 supérieure ou égale à 50.

]]> 1.0 0.0 0 true true abc Rien, la boucle ne s'arrête jamais

]]> Erreur : n augmente à chaque tour et finit par dépasser 50 :
la condition devient fausse.

]]> 50

]]> Erreur : 50 est le seuil de la condition, mais n ne prend que
des puissances de 3.

]]> 81

]]> Bonne réponse : n prend les valeurs 1, 3, 9, 27, puis
81. Comme 81 < 50 est faux, la boucle s'arrête.

]]> 27

]]> Erreur : 27 < 50 est vrai, donc la boucle fait encore un tour
et n devient 81.

]]> Algorithmique et programmation — Q18 : Choisir le type de boucle Un capital de 1 000 euros augmente de 3\ % par an. On cherche
le nombre d'années nécessaires pour qu'il dépasse 1 500 euros.
Quelle boucle convient ?

]]> Boucle bornée (for) : le nombre de répétitions est connu à
l'avance. Boucle non bornée (while) : on répète jusqu'à ce qu'une
condition change, comme un dépassement de seuil.

]]> 1.0 0.0 0 true true abc Une boucle for i in range(1500)

]]> Erreur : 1 500 est un montant, pas un nombre d'années. Cette
boucle ferait 1 500 tours sans s'arrêter au seuil.

]]> Une boucle while, arrêtée au seuil

]]> Bonne réponse : on répète tant que le capital ne dépasse pas
1 500, et l'on compte les tours.

]]> Une boucle for, car on connaît le taux

]]> Erreur : connaître le taux ne donne pas le nombre de tours. C'est
justement ce nombre que l'on cherche.

]]> Aucune boucle, un seul calcul suffit

]]> Erreur : en seconde, sans outil pour inverser 1{,}03^n, on
calcule les capitaux année après année.

]]> Algorithmique et programmation — Q19 : Compléter un algorithme de seuil On veut afficher le nombre d'années au bout duquel le capital de
1 000 euros, placé à 3\ % par an, dépasse 1 500 euros.
Quelle ligne manque ?

`python c = 1000 n = 0 while c <= 1500: c = c * 1.03 ... print(n)`

]]> Algorithme de seuil : une variable évolue dans la boucle et une
autre compte les tours. À la sortie, le compteur donne le premier
rang où la condition est dépassée.

]]> 1.0 0.0 0 true true abc n = n + 1

]]> Bonne réponse : n compte les années. Il augmente de 1 à
chaque tour, en même temps que le capital.

]]> c = c + 1

]]> Erreur : le capital est déjà mis à jour à la ligne précédente, et
n resterait à 0.

]]> n = 1

]]> Erreur : n vaudrait toujours 1, quel que soit le nombre de
tours effectués.

]]> n = c

]]> Erreur : n recevrait le montant du capital, pas un nombre
d'années.

]]> Algorithmique et programmation — Q20 : Une boucle qui ne s'arrête pas Pourquoi ce programme ne s'arrête-t-il jamais ?

`python x = 10 while x > 0: x = x + 2`

]]> Avant d'écrire une boucle while, on vérifie que le corps de la
boucle fait évoluer les variables vers la sortie.

]]> 1.0 0.0 0 true true abc La variable x n'est pas initialisée

]]> Erreur : la première ligne donne à x la valeur 10.

]]> Une boucle while s'exécute toujours sans fin

]]> Erreur : une boucle while s'arrête dès que sa condition
devient fausse.

]]> Il manque une instruction print

]]> Erreur : l'absence d'affichage n'empêche pas un programme de se
terminer.

]]> x augmente, donc x > 0 reste toujours vrai

]]> Bonne réponse : la condition de sortie ne devient jamais fausse.
Il faudrait par exemple x = x - 2.

]]> Algorithmique et programmation — Q21 : Des tours qui modifient une valeur Qu'affiche ce programme ?

`python u = 2 for i in range(3): u = 2 * u + 1 print(u)`

]]> Pour lire une boucle, on dresse un tableau des valeurs successives
de la variable, un tour par ligne.

]]> 1.0 0.0 0 true true abc 23

]]> Bonne réponse : la boucle applique 3 fois la transformation
« doubler puis ajouter 1 » à partir de 2.

]]> 16

]]> Erreur : l'ajout de 1 à chaque tour a été oublié.

]]> 47

]]> Erreur : un tour de trop. range(3) fait 3 tours, pas
3 + 1.

]]> 11

]]> Erreur : il manque un tour. range(3) fait exactement 3
tours.

]]> Algorithmique et programmation — Q22 : Une condition dans une boucle Qu'affiche ce programme ?

`python c = 0 for k in range(1, 21): if k % 3 == 0 or k % 5 == 0: c = c + 1 print(c)`

]]> Le compteur augmente une fois par valeur de k qui vérifie la
condition. Une condition avec or est vraie dès qu'une des deux
parties l'est.

]]> 1.0 0.0 0 true true abc 1

]]> Erreur : ce serait le nombre d'entiers multiples de 3 et
de 5. Le mot or demande l'un ou l'autre.

]]> 9

]]> Bonne réponse : 6 multiples de 3 et 4 multiples de 5
entre 1 et 20, mais 15 est compté deux fois : 6 + 4 - 1.

]]> 10

]]> Erreur : 15 est multiple de 3 et de 5, mais le compteur
n'augmente qu'une fois pour lui.

]]> 8

]]> Erreur : l'entier 20 est bien examiné, car range(1, 21)
s'arrête à 20.

]]> Algorithmique et programmation — Q23 : Appeler une fonction On définit la fonction suivante. Que vaut f(3) ?

`python def f(x): return x ** 2 - 4`

]]> Appeler f(a), c'est exécuter le corps de la fonction avec le
paramètre x égal à a. L'instruction return renvoie le
résultat.

]]> 1.0 0.0 0 true true abc 2

]]> Erreur : x ** 2 est le carré de x, pas son double.

]]> 5

]]> Bonne réponse : on remplace x par 3 dans l'expression renvoyée : on élève 3 au carré, puis on retranche 4, ce qui donne 5.

]]> 13

]]> Erreur de signe : la fonction retranche 4 au carré.

]]> x ** 2 - 4

]]> Erreur : l'appel f(3) renvoie une valeur numérique, calculée
avec x = 3.

]]> Algorithmique et programmation — Q24 : Écrire une fonction affine Quelle définition correspond à la fonction g : x ↦ 3x - 1 ?

]]> Une fonction Python se définit par def nom(paramètre):, suivi d'un
bloc indenté qui se termine par return valeur.

]]> 1.0 0.0 0 true true abc `

python

def g(x):

    y = 3 * x - 1

]]> Erreur : la valeur est calculée puis perdue. Sans return, la
fonction ne renvoie rien d'utilisable.

]]> `

python

def g(x):

    return 3 * x - 1

]]> Bonne réponse : l'en-tête nomme la fonction et son paramètre, et
return renvoie l'image.

]]> `

python

g(x) = 3 * x - 1

]]> Erreur : c'est une écriture mathématique. En Python, une
fonction se définit avec def.

]]> `

python

def g(x):

    print(3x - 1)

]]> Erreur : 3x n'est pas une écriture valide, et print affiche
la valeur sans la renvoyer : g(2) + 1 échouerait.

]]> Algorithmique et programmation — Q25 : Renvoyer ou afficher Quelle différence y a-t-il entre return et print dans une
fonction ?

]]> Une fonction mathématique associe une image à un nombre : en Python,
c'est return qui fournit cette image au reste du programme.

]]> 1.0 0.0 0 true true abc return ne s'utilise qu'avec des nombres entiers

]]> Erreur : une fonction peut renvoyer un flottant, une chaîne ou un
booléen.

]]> Aucune : les deux font apparaître le résultat

]]> Erreur : une valeur affichée par print ne peut pas être
réutilisée dans un calcul.

]]> return rend la valeur réutilisable

]]> Bonne réponse : la valeur renvoyée peut être rangée dans une
variable ou réutilisée dans un calcul. print se contente de
l'afficher à l'écran.

]]> print arrête la fonction, return non

]]> Erreur : c'est l'inverse. return termine immédiatement la
fonction.

]]> Algorithmique et programmation — Q26 : Une fonction à deux paramètres On définit la fonction suivante. Que vaut moyenne(12, 17) ?

`python def moyenne(a, b): return (a + b) / 2`

]]> Lors de l'appel, les arguments sont affectés aux paramètres dans
l'ordre : le premier à a, le second à b.

]]> 1.0 0.0 0 true true abc 14{,}5

]]> Bonne réponse : a vaut 12 et b vaut 17 :
(12 + 17) / 2 = 14{,}5.

]]> 20{,}5

]]> Erreur de priorité : les parenthèses imposent de faire la somme
avant la division, pas 12 + 17 / 2.

]]> 14{,}0

]]> Erreur : 12 + 17 = 29 est impair, sa moitié n'est donc pas un entier.

]]> 29

]]> Erreur : la somme a bien été calculée, mais pas la division par
2.

]]> Algorithmique et programmation — Q27 : Une fonction qui teste On veut une fonction est_diviseur(d, n) qui renvoie True si d
divise l'entier n, et False sinon. Quelle définition convient ?

]]> Une condition est une expression de type booléen : on peut la
renvoyer telle quelle, sans if.

]]> 1.0 0.0 0 true true abc `

python

def est_diviseur(d, n):

    return n // d

]]> Erreur : cette fonction renvoie un quotient, pas un booléen.

]]> `

python

def est_diviseur(d, n):

    return n % d == 0

]]> Bonne réponse : la comparaison n % d == 0 vaut déjà True ou
False, on la renvoie directement.

]]> `

python

def est_diviseur(d, n):

    return d % n == 0

]]> Erreur : les rôles sont inversés. Ce test indique si n divise
d.

]]> `

python

def est_diviseur(d, n):

    if n % d == 0:

        return True

]]> Erreur : si d ne divise pas n, aucune instruction return
n'est exécutée et la fonction ne renvoie pas False.

]]> Algorithmique et programmation — Q28 : Simuler un lancer de dé Le module random est importé. Quelle fonction renvoie le résultat
d'un lancer de dé équilibré à six faces ?

]]> random.randint(a, b) renvoie un entier aléatoire de a à b,
bornes incluses ; random.random() renvoie un flottant de
[0 ; 1[.

]]> 1.0 0.0 0 true true abc `

python

def de():

    return random.randint(1, 6)

]]> Bonne réponse : randint(1, 6) renvoie un entier au hasard entre
1 et 6, bornes comprises, chacun avec la même
probabilité.

]]> `

python

def de():

    return 6 * random.random()

]]> Erreur : random() renvoie un flottant. On obtiendrait des
valeurs comme 3{,}74, pas des entiers.

]]> `

python

def de():

    return random.randint(1, 7)

]]> Erreur : les deux bornes de randint sont comprises, donc 7
pourrait sortir.

]]> `

python

def de():

    return random.randint(0, 6)

]]> Erreur : cette fonction peut renvoyer 0, qui n'est pas une face
du dé : il y aurait sept résultats possibles.

]]> Algorithmique et programmation — Q29 : Fréquence de six sur des lancers Le module random est importé. Que renvoie f(1000) ?

`python def f(n): c = 0 for i in range(n): if random.randint(1, 6) == 6: c = c + 1 return c / n`

]]> Fonction de simulation : répéter une expérience aléatoire, compter
les succès, renvoyer la fréquence. La loi des grands nombres
explique qu'elle se rapproche de la probabilité quand n grandit.

]]> 1.0 0.0 0 true true abc La fréquence de six sur 1 000 lancers

]]> Bonne réponse : c compte les six obtenus, puis on divise par
le nombre de lancers. Le résultat est souvent proche de
⅙.

]]> Le dernier résultat du dé

]]> Erreur : les résultats des lancers ne sont pas conservés. Seul
le compteur c l'est.

]]> Exactement ⅙

]]> Erreur : le résultat dépend du hasard et varie d'un appel à
l'autre, autour de ⅙.

]]> Le nombre de six sur 1 000 lancers

]]> Erreur : ce serait return c. La division par n transforme
l'effectif en fréquence.

]]> Algorithmique et programmation — Q30 : Modifier une fonction de seuil La fonction ci-dessous renvoie le nombre d'années nécessaires pour
qu'un capital de 1 000 euros, placé à 3\ % par an, dépasse le
montant m. Comment la modifier pour que le taux devienne un
paramètre t exprimé en pourcentage ?

`python def annees(m): c = 1000 n = 0 while c <= m: c = c * 1.03 n = n + 1 return n`

]]> Transformer une valeur écrite en dur en paramètre rend la fonction
réutilisable : on l'ajoute dans l'en-tête, puis on l'utilise dans le
corps.

]]> 1.0 0.0 0 true true abc En-tête def annees(m, t): et ligne c = c * t

]]> Erreur : pour t = 3, le capital serait multiplié par 3, soit
une hausse de 200\ %.

]]> Ligne c = c * (1 + t / 100) sans changer l'en-tête

]]> Erreur : t ne serait défini nulle part, ce qui provoque une
erreur à l'exécution. Il doit figurer parmi les paramètres.

]]> En-tête def annees(m, t): et ligne c = c + t

]]> Erreur : on ajouterait t euros par an, une évolution linéaire
et non une hausse en pourcentage.

]]> En-tête def annees(m, t):, facteur 1 + t / 100

]]> Bonne réponse : une hausse de t\ % multiplie par
1 + t/100. Pour t = 3, on retrouve 1{,}03.

]]> Algorithmique et programmation — Q31 : Le signe d'un nombre par un test à trois branches Qu'affiche ce programme ?
`

python

x = 0

if x < 0:

    print("negatif")

elif x == 0:

    print("nul")

else:

    print("positif")

]]> Une structure if, elif, else partage les valeurs en cas
disjoints : négatif, nul ou positif.

]]> 1.0 0.0 0 true true abc negatif

]]> Erreur : relisez la comparaison de 0 avec 0 dans chaque
test.

]]> nul

]]> Bonne réponse : les tests sont examinés dans l'ordre et la
première condition vraie l'emporte ; pour x = 0, c'est la
branche nul.

]]> positif

]]> Erreur : cette branche correspond à une autre valeur de x.

]]> Les trois mots, chaque branche étant parcourue

]]> Erreur : avec elif et else, une seule branche s'exécute.

]]> Algorithmique et programmation — Q32 : Afficher le plus grand de deux nombres Qu'affiche ce programme ?
`

python

a = 7

b = 12

if a > b:

    print(a)

else:

    print(b)

]]> Ce programme calcule le maximum de deux nombres : une condition
choisit la valeur à afficher.

]]> 1.0 0.0 0 true true abc 19, la somme

]]> Erreur : aucune addition n'est faite.

]]> 7, la plus petite

]]> Erreur : le test a > b sélectionne la plus grande valeur.

]]> 12

]]> Bonne réponse : le programme affiche a si a > b, sinon b ;
dans les deux cas, c'est la plus grande des deux valeurs, ou leur
valeur commune si elles sont égales.

]]> 7 puis 12

]]> Erreur : une seule des deux branches s'exécute.

]]> Algorithmique et programmation — Q33 : En dehors d'un intervalle Qu'affiche ce programme ?
`

python

x = 5

if x < 2 or x > 8:

    print("hors")

else:

    print("dans")

]]> « En dehors de [2 ; 8] » se traduit par x < 2 or x > 8 ; « dans »
par 2 <= x <= 8.

]]> 1.0 0.0 0 true true abc dans, 5 étant entre 2 et 8

]]> Bonne réponse : la condition x < 2 or x > 8 est vraie dès
qu'une des deux comparaisons l'est ; sinon, x est dans
[2 ; 8].

]]> 5, la valeur de x

]]> Erreur : le programme affiche un mot, pas la valeur de x.

]]> hors, 5 n'étant ni 2 ni 8

]]> Erreur : testez chaque comparaison avec x = 5 ; un seul
or vrai suffit à afficher hors.

]]> Une erreur, deux comparaisons ne pouvant être combinées

]]> Erreur : or sert précisément à combiner deux conditions.

]]> Algorithmique et programmation — Q34 : Une condition avant une racine carrée Avant de calculer sqrt(x) dans un programme, quelle condition
faut-il tester pour éviter une erreur ?

]]> Un test conditionnel sert aussi à vérifier qu'un calcul est
possible : domaine de définition d'une racine, d'un quotient.

]]> 1.0 0.0 0 true true abc x > 0, zéro n'ayant pas de racine carrée définie

]]> Erreur : √0 = 0 existe ; exclure zéro est inutile.

]]> x >= 0, la racine exigeant un nombre positif ou nul

]]> Bonne réponse : √x n'existe que pour x ≥ 0 ; le
test protège l'appel de sqrt, qui échouerait pour un nombre
négatif.

]]> x != 0, pour éviter une division par zéro cachée

]]> Erreur : il n'y a pas de division ici ; le danger est un nombre
négatif.

]]> x <= 0, la racine carrée demandant un nombre négatif

]]> Erreur : c'est l'inverse, la racine carrée demande un nombre
positif ou nul.

]]> Algorithmique et programmation — Q35 : Additionner deux chaînes de chiffres Que vaut l'expression "3" + "4" ?

]]> Le même symbole + additionne des nombres et concatène des
chaînes : le type des valeurs décide.

]]> 1.0 0.0 0 true true abc '7', la somme écrite entre guillemets

]]> Erreur : Python ne calcule pas sur des chaînes, il les
juxtapose.

]]> Une erreur, les chaînes ne pouvant pas s'additionner

]]> Erreur : + entre deux chaînes est autorisé et les concatène.

]]> 7, la somme des deux entiers

]]> Erreur : les guillemets font de "3" et "4" des chaînes,
pas des entiers ; il faudrait int("3") + int("4").

]]> '34', la concaténation des deux chaînes

]]> Bonne réponse : entre guillemets, "3" et "4" sont des
chaînes de caractères ; + les met bout à bout.

]]> Algorithmique et programmation — Q36 : Deux affectations successives sur une variable Que vaut a à la fin de ce programme ?
`

python

a = 5

a = a + 3

a = a * 2

]]> Chaque affectation remplace la valeur de a par le résultat du
calcul fait avec sa valeur courante.

]]> 1.0 0.0 0 true true abc 11, le produit étant prioritaire sur l'addition

]]> Erreur : il n'y a pas une expression mais deux instructions
exécutées l'une après l'autre.

]]> 16, l'addition puis le produit, dans l'ordre

]]> Bonne réponse : après la deuxième ligne a vaut 8,
puis la troisième la multiplie par 2.

]]> 13, le produit effectué avant l'addition

]]> Erreur : les instructions s'exécutent dans l'ordre d'écriture.

]]> 10, les trois nombres additionnés

]]> Erreur : la troisième ligne multiplie, elle n'additionne pas.

]]> Algorithmique et programmation — Q37 : Priorité de la puissance dans une affectation Que vaut x après l'instruction x = 2 * 3 2 ?

]]> En Python comme en mathématiques, la puissance précède le produit.

]]> 1.0 0.0 0 true true abc 12, les trois nombres multipliés

]]> Erreur : ** est une puissance, pas une multiplication.

]]> 8, le produit puis la somme

]]> Erreur : il n'y a ni somme ni produit 2 × 3.

]]> 16, la puissance étant calculée avant le produit

]]> Bonne réponse : * est prioritaire sur , donc
2³ × 2 = 16.

]]> 64, le produit des exposants

]]> Erreur : c'est 2 * (3 2) qui donnerait ce résultat.

]]> Algorithmique et programmation — Q38 : Année bissextile Qu'affiche ce programme ?
`

python

a = 1900

if a % 4 == 0 and a % 100 != 0 or a % 400 == 0:

    print("bissextile")

else:

    print("non bissextile")

]]> Une année est bissextile si elle est divisible par 4 sans
l'être par 100, ou si elle est divisible par 400.

]]> 1.0 0.0 0 true true abc bissextile, 1900 étant un multiple de 4

]]> Erreur : être multiple de 4 ne suffit pas, la condition
exige aussi a % 100 != 0.

]]> Une erreur, and et or ne pouvant pas se mélanger

]]> Erreur : Python accepte le mélange ; and est évalué avant
or.

]]> bissextile, la dernière condition l'emportant toujours

]]> Erreur : a % 400 == 0 est faux pour 1900.

]]> non bissextile, 1900 étant divisible par 100 mais pas par 400

]]> Bonne réponse : a % 4 == 0 and a % 100 != 0 est faux car
1900 est multiple de 100, et a % 400 == 0 est faux
aussi.

]]> Algorithmique et programmation — Q39 : Les valeurs parcourues par range Quelles valeurs prend i dans la boucle for i in range(2, 7): ?

]]> range(a, b) parcourt les entiers de a inclus à b exclu.

]]> 1.0 0.0 0 true true abc 0, 1, 2, 3, 4, 5 et 6

]]> Erreur : le premier argument fixe le départ à 2.

]]> 2, 3, 4, 5, 6 et 7

]]> Erreur : la borne de fin est exclue.

]]> 1, 2, 3, 4, 5, 6 et 7

]]> Erreur : la boucle commence à 2 et exclut 7.

]]> 2, 3, 4, 5 et 6

]]> Bonne réponse : range(2, 7) part de 2 et s'arrête avant
7.

]]> Algorithmique et programmation — Q40 : Un produit calculé par une boucle Qu'affiche ce programme ?
`

python

p = 1

for i in range(1, 5):

    p = p * i

print(p)

]]> Un accumulateur initialisé à 1 et multiplié à chaque tour
calcule un produit.

]]> 1.0 0.0 0 true true abc 120, le produit des entiers de 1 à 5

]]> Erreur : 5 est exclu de range(1, 5).

]]> 10, la somme des entiers de 1 à 4

]]> Erreur : l'instruction multiplie, elle n'additionne pas.

]]> 4, la dernière valeur de i

]]> Erreur : le programme affiche p, pas i.

]]> 24, le produit des entiers de 1 à 4

]]> Bonne réponse : range(1, 5) s'arrête à 4 et p est
multiplié par chaque entier rencontré.

]]> Algorithmique et programmation — Q41 : Compter avec un test de divisibilité Qu'affiche ce programme ?
`

python

c = 0

for i in range(1, 21):

    if i % 3 == 0:

        c = c + 1

print(c)

]]> Un compteur placé sous un test ne compte que les valeurs qui
vérifient la condition.

]]> 1.0 0.0 0 true true abc 6, les multiples de 3 jusqu'à 20

]]> Bonne réponse : c augmente de 1 à chaque fois que i est
divisible par 3, soit 6 fois jusqu'à 20.

]]> 20, le nombre total de tours de boucle

]]> Erreur : c ne compte que les tours où le test est vrai.

]]> 7, en comptant aussi 21 comme multiple

]]> Erreur : range(1, 21) s'arrête à 20.

]]> 3, le diviseur utilisé dans le test

]]> Erreur : le programme affiche le compteur, pas le diviseur.

]]> Algorithmique et programmation — Q42 : Somme des premiers entiers jusqu'à un seuil Qu'affiche ce programme ?
`

python

s = 0

n = 0

while s <= 20:

    n = n + 1

    s = s + n

print(n)

]]> Une boucle while répète tant que la condition est vraie : elle
s'arrête au premier n pour lequel la somme dépasse le seuil.

]]> 1.0 0.0 0 true true abc 6, premier rang où la somme dépasse 20

]]> Bonne réponse : la boucle ajoute 1, puis 2, puis 3, et
s'arrête dès que s dépasse 20 ; cela se produit pour
n = 6, avec s égal à 21.

]]> 21, la valeur finale de la somme s

]]> Erreur : le programme affiche n, pas s.

]]> 20, le seuil comparé à la somme

]]> Erreur : 20 est la valeur comparée, pas le nombre de tours.

]]> 5, dernier rang où la somme reste sous 20

]]> Erreur : pour n = 5, s est encore inférieur ou égal à
20 et la boucle fait un tour de plus.

]]> Algorithmique et programmation — Q43 : Une fonction qui oublie de renvoyer Qu'affiche ce programme ?
``python
def double(x):
y = 2 * x

r = double(5)
print(r)
``

]]> Pour qu'un appel produise une valeur, la fonction doit se terminer
par return.

]]> 1.0 0.0 0 true true abc 10, la valeur calculée dans la fonction

]]> Erreur : y est calculé mais jamais renvoyé.

]]> 5, l'argument passé à la fonction

]]> Erreur : la fonction ne renvoie pas son argument.

]]> None, la fonction ne renvoyant rien

]]> Bonne réponse : sans return, l'appel double(5) vaut
None, même si y a été calculé à l'intérieur.

]]> Une erreur, y n'existant pas en dehors de la fonction

]]> Erreur : le programme n'utilise pas y à l'extérieur ; il
affiche r, qui vaut None.

]]> Algorithmique et programmation — Q44 : Deux appels d'une fonction à condition Qu'affiche ce programme ?
``python
def tarif(age):
if age < 12:
return 5
else:
return 8

print(tarif(10) + tarif(15))
``

]]> Chaque appel est évalué séparément avec son argument, puis les
deux valeurs renvoyées sont additionnées.

]]> 1.0 0.0 0 true true abc 5 8, les deux tarifs l'un après l'autre

]]> Erreur : print reçoit la somme des deux valeurs renvoyées.

]]> 16, soit 8 + 8

]]> Erreur : 10 est strictement inférieur à 12.

]]> 10, soit 5 + 5

]]> Erreur : 15 n'est pas strictement inférieur à 12.

]]> 13, soit 5 + 8

]]> Bonne réponse : tarif(10) renvoie 5 car 10 < 12, et
tarif(15) renvoie 8.

]]> Algorithmique et programmation — Q45 : Une fonction qui en appelle une autre Qu'affiche ce programme ?
``python
def carre(x):
return x * x

def somme_carres(a, b):
return carre(a) + carre(b)

print(somme_carres(3, 4))
``

]]> Une fonction peut en appeler une autre ; chaque appel renvoie une
valeur utilisée dans le calcul.

]]> 1.0 0.0 0 true true abc 49, soit (3 + 4)²

]]> Erreur : chaque nombre est élevé au carré avant l'addition.

]]> 25, soit 3² + 4²

]]> Bonne réponse : somme_carres appelle carre deux fois et
additionne les valeurs renvoyées.

]]> 12, le produit 3 × 4

]]> Erreur : aucun produit de a par b n'est calculé.

]]> 7, la somme 3 + 4

]]> Erreur : carre est bien appliquée à chaque argument.

]]>