Q1. On considère L = [12, 5, 8, 21, 7]. Quelle est la valeur de L[-2] ? Non vérifié

\(21\) \(7\) \(8\) \(5\)

Indice

Compter depuis la fin : l’indice -1 désigne le dernier élément.

Correction

Le dernier élément est L[-1]=7. L’avant-dernier est donc L[-2]=21.

Q2. On exécute L = [4, 7, 12], puis L.append(9), puis x = L.pop(1). Quel couple (L, x) obtient-on ? Non vérifié

([4, 12, 9], 7) ([4, 7, 12], 9) ([7, 12, 9], 4) ([4, 9, 12], 7)

Indice

Écrire la liste après append, puis repérer l’élément d’indice 1.

Correction

Après append(9), la liste vaut [4, 7, 12, 9]. pop(1) retire et renvoie l’élément 7. Il reste [4, 12, 9] et x=7.

Q3. Que produit [2*n + 1 for n in range(5)] ? Non vérifié

[1, 3, 5, 7, 9] [3, 5, 7, 9, 11] [1, 3, 5, 7] [0, 2, 4, 6, 8]

Indice

Déterminer d’abord les cinq valeurs prises par n.

Correction

range(5) fournit 0, 1, 2, 3 et 4. Les valeurs de 2*n+1 sont donc 1, 3, 5, 7 et 9.

Q4. Si len(L)=6, quelles sont exactement les valeurs prises par i dans for i in range(len(L)): ? Non vérifié

0, 1, 2, 3, 4, 5 1, 2, 3, 4, 5, 6 0, 1, 2, 3, 4, 5, 6 1, 2, 3, 4, 5

Indice

range(n) commence à 0 et s’arrête juste avant n.

Correction

range(6) produit 0, 1, 2, 3, 4, 5. Ce sont précisément les six indices valides d’une liste de taille 6.

Q5. Quelle compréhension construit les entiers pairs de 1 à 10 inclus ? Non vérifié

[n for n in range(1, 11) if n % 2 == 0] [n for n in range(1, 10) if n % 2 == 0] [n for n in range(1, 11) if n % 2 == 1] [2*n for n in range(1, 11) if n == 0]

Indice

Vérifier séparément la borne supérieure du range et le test de parité.

Correction

range(1,11) parcourt les entiers de 1 à 10, et n % 2 == 0 conserve exactement les pairs.

Q6. On exécute :

s = 0
for x in [1, 2, 4]:
    s = s + x*x

Quelle est la valeur finale de s ? Non vérifié

\(21\) \(14\) \(49\) \(7\)

Indice

Le programme additionne les carrés, pas les valeurs elles-mêmes.

Correction

Le programme calcule \(1^2+2^2+4^2=1+4+16=21\).

Q7. On considère la fonction :

def nb_sup(L, a):
    c = 0
    for x in L:
        if x > a:
            c = c + 1
    return c

Que renvoie nb_sup([4,12,7,15,18], 10) ? Non vérifié

\(3\) \(2\) \(4\) \(52\)

Indice

Compter uniquement les éléments strictement supérieurs au seuil.

Correction

Les valeurs strictement supérieures à 10 sont 12, 15 et 18. Le compteur est donc incrémenté trois fois et la fonction renvoie 3.

Q8. Pourquoi initialise-t-on généralement un algorithme de maximum par maxi = L[0] plutôt que par maxi = 0 ? Non vérifié

Parce que la liste peut ne contenir que des nombres négatifs Parce que L[0] est toujours le maximum Parce que 0 ne peut jamais appartenir à une liste Parce que Python interdit maxi = 0

Indice

Tester mentalement le cas d’une liste dont tous les éléments sont inférieurs à 0.

Correction

Avec une liste comme [-8,-3,-12], initialiser maxi=0 ferait conserver 0 alors qu’il n’appartient pas à la liste. Initialiser avec L[0] donne une valeur réellement présente.

Q9. On définit \(u_0=1\) et \(u_{n+1}=2u_n+3\). Le programme construit U=[u0] puis ajoute quatre termes successifs. Quelle liste doit-il obtenir ? Non vérifié

[1, 5, 13, 29, 61] [1, 5, 13, 29] [1, 2, 4, 8, 16] [1, 5, 10, 20, 40]

Indice

Appliquer quatre fois la relation de récurrence en partant de u0=1.

Correction

\(u_1=5\), \(u_2=13\), \(u_3=29\), \(u_4=61\). Comme la liste contient aussi \(u_0\), elle vaut [1, 5, 13, 29, 61].

Q10. Le code suivant doit renvoyer le premier indice de 7 :

pos = -1
for i in range(len(L)):
    if L[i] == 7:
        pos = i

Quel est son défaut ? Non vérifié

Il conserve la dernière occurrence de 7 si plusieurs existent Il ne peut jamais trouver 7 Il commence à l’indice 1 Il modifie les valeurs de L

Indice

Observer ce qui se passe si la condition est vraie plusieurs fois.

Correction

À chaque nouvelle occurrence de 7, pos est remplacé par le nouvel indice. Sans arrêt ni condition supplémentaire, la valeur finale correspond donc à la dernière occurrence.

Q11. Que produit [n for n in range(1, 11) if n*n - 7*n + 10 <= 0] ? Non vérifié

[2, 3, 4, 5] [1, 2, 3, 4, 5] [2, 5] [6, 7, 8, 9, 10]

Indice

Factoriser le trinôme puis déterminer sur quels entiers il est négatif ou nul.

Correction

On factorise \(n^2-7n+10=(n-2)(n-5)\). Le produit est négatif ou nul pour \(2\le n\le5\). Parmi les entiers de 1 à 10, on obtient donc [2, 3, 4, 5].

Q12. On considère :

def f(L):
    R = []
    for x in L:
        if x % 2 == 0:
            R.append(x*x)
    return R

Que renvoie f([2,3,4,5,6]) ? Non vérifié

[4, 16, 36] [2, 4, 6] [4, 9, 16, 25, 36] [9, 25]

Indice

Le programme effectue d’abord un filtrage puis une transformation.

Correction

Les éléments pairs sont 2, 4 et 6. Le programme ajoute leurs carrés : 4, 16 et 36. Il renvoie donc [4, 16, 36].

Q13. Quelles écritures construisent exactement la liste des carrés des éléments de L ? Non vérifié

R = [x*x for x in L] R = [] ; for x in L: R.append(x*x) R = [] ; for i in range(len(L)): R.append(L[i]*L[i]) R = [x for x in L if x*x]

Indice

Chaque bonne écriture doit produire un carré pour chaque élément de L, sans filtrer d’élément.

Correction

Les trois premières écritures calculent un carré pour chaque élément. La dernière conserve les valeurs x elles-mêmes lorsque x*x est considéré vrai ; elle ne construit donc pas la liste des carrés.

Q14. À propos des fonctions Python utilisées en algorithmique, quelles affirmations sont correctes ? Non vérifié

return permet de renvoyer une valeur utilisable ensuite Les paramètres sont les entrées de la fonction print et return ont toujours exactement le même rôle Découper un problème en plusieurs fonctions peut rendre le programme plus clair

Indice

Distinguer ce qui est affiché à l’écran de ce qui est réellement renvoyé au programme appelant.

Correction

return produit une sortie réutilisable ; les paramètres sont des entrées ; la programmation modulaire clarifie la structure. print ne remplace pas return.

Q15. On considère notes=[12,8,15,5] et coef=[2,1,3,2]. On calcule la moyenne pondérée \(m=\dfrac{\sum notes_i\,coef_i}{\sum coef_i}\). Donner la valeur exacte de m sous forme décimale. Non vérifié

Indice

Calculer séparément la somme pondérée et la somme des coefficients.

Correction

La somme pondérée vaut \(12\times2+8\times1+15\times3+5\times2=87\). La somme des coefficients vaut \(2+1+3+2=8\). Donc \(m=\dfrac{87}{8}=10{,}875\).

Q16. On exécute :

u = 5
n = 0
while u <= 1000:
    u = 1.5*u + 2
    n = n + 1

Quelle est la valeur finale de n ? Non vérifié

Indice

La boucle s’arrête au premier terme strictement supérieur à 1000.

Correction

Les termes successifs finissent par donner environ 774,478 au rang 11 puis 1163,717 au rang 12. Le premier dépassement de 1000 se produit donc au rang 12.

Q17. On définit L = [n*n - 3*n + 2 for n in range(7)]. Combien d’éléments de L sont nuls ? Non vérifié

Indice

Factoriser l’expression n²−3n+2.

Correction

\(n^2-3n+2=(n-1)(n-2)\). Pour \(n=0,1,\ldots,6\), l’expression est nulle exactement pour \(n=1\) et \(n=2\). Il y a donc 2 zéros.

Q18. On veut une fonction qui renvoie tous les éléments strictement positifs d’une liste. Quelles stratégies sont correctes ? Non vérifié

return [x for x in L if x > 0] R=[] ; for x in L: if x > 0: R.append(x) ; return R R=[] ; for x in L: if x <= 0: R.append(x) ; return R return len([x for x in L if x > 0])

Indice

La sortie attendue doit être une liste de valeurs, pas un nombre.

Correction

Les deux premières stratégies renvoient exactement les valeurs strictement positives. La troisième conserve les non-positifs ; la quatrième renvoie seulement leur nombre.

Q19. On exécute :

L = [2, 6, 18, 54]
ok = True
for i in range(len(L)-1):
    if L[i+1] != 3*L[i]:
        ok = False

Que signifie la valeur finale ok=True ? Non vérifié

Chaque terme après le premier est trois fois le précédent Chaque terme est supérieur de 3 au précédent La liste contient exactement trois éléments Tous les éléments sont divisibles par 54

Indice

Lire littéralement l’égalité testée entre deux éléments consécutifs.

Correction

Le test compare chaque L[i+1] à 3*L[i]. Comme il reste vrai pour tous les indices testés, chaque terme après le premier est exactement trois fois son prédécesseur.

Q20. On construit L = [2**n for n in range(10) if 2**n < 100]. Donner le nombre d’éléments de L. Non vérifié

Indice

Lister les puissances de 2 strictement inférieures à 100 à partir de 2⁰.

Correction

Les valeurs sont \(1,2,4,8,16,32,64\). La puissance suivante vaut \(128\), qui n’est plus inférieure à 100. La liste contient donc 7 éléments.

Quiz de maths 1ère spé : Algorithmique — Listes

Quiz — Algorithmique : Listes