(a) Le premier élément est celui d’indice 0, donc c’est 12.

(b) L’élément d’indice 2 est le troisième élément de la liste : 8.

(c) Le dernier élément est 7.

(d) La liste contient 5 éléments, donc len(L)=5.

Réponses : (a) 12 ; (b) 8 ; (c) 7 ; (d) 5.

(a) Le nombre 9 est d’indice 1, donc on écrit L[1].

(b) Le nombre 3 est d’indice 2, donc on remplace avec L[2] = 10.

(c) Pour ajouter 15 à la fin, on écrit L.append(15).

(d) Après modification, la liste devient [4, 9, 10, 6, 15].

Réponses : (a) L[1] ; (b) L[2]=10 ; (c) L.append(15) ; (d) [4, 9, 10, 6, 15].

(a) Une écriture correcte est :

for x in L:
    print(x)

(b) Les valeurs sont affichées dans l’ordre : 2, puis 5, puis 7, puis 4.

(c) La boucle s’exécute 4 fois car la liste contient 4 éléments.

(d) À la 3e itération, la variable x vaut 7.

Réponses : (a) boucle ci-dessus ; (b) 2, 5, 7, 4 ; (c) 4 fois ; (d) 7.

(a) Une écriture correcte est :

for i in range(len(L)):
    print(i, L[i])

(b) La liste contient 4 éléments, donc i prend les valeurs 0, 1, 2 et 3.

(c) Quand i = 2, on a L[2] = 14.

(d) Cette méthode est pratique lorsqu’on cherche un indice, lorsqu’on veut modifier un élément précis, ou lorsqu’on veut comparer plusieurs positions.

Réponses : (a) boucle ci-dessus ; (b) 0,1,2,3 ; (c) 14 ; (d) on a accès aux positions.

(a) On peut écrire :

s = 0
for x in L:
    s = s + x

(b) On initialise la variable s.

(c) La somme vaut \(3+8+2+7+10 = 30\).

(d) On initialise à 0 car 0 est l’élément neutre de l’addition : commencer avec une autre valeur fausserait le résultat.

Réponses : (a) algorithme ci-dessus ; (b) s ; (c) 30 ; (d) car 0 n’ajoute rien à la somme.

(a) La somme vaut \(6+9+5+8+12 = 40\).

(b) La liste contient 5 éléments.

(c) La moyenne vaut \(\dfrac{40}{5}=8\).

(d) On peut écrire :

s = 0
for x in L:
    s = s + x
moy = s / len(L)

Réponses : (a) 40 ; (b) 5 ; (c) 8 ; (d) algorithme ci-dessus.

(a) Le maximum est 19.

(b) On initialise avec L[0] car on veut partir d’une valeur réellement présente dans la liste.

(c) On peut écrire :

maxi = L[0]
for x in L:
    if x > maxi:
        maxi = x

(d) Après le passage du nombre 19, la variable maxi vaut 19.

Réponses : (a) 19 ; (b) on part d’un élément réel de la liste ; (c) algorithme ci-dessus ; (d) 19.

(a) Le minimum est 6.

(b) On peut écrire :

mini = L[0]
for x in L:
    if x < mini:
        mini = x

(c) Après lecture du deuxième élément, on a déjà vu 14 puis 6, donc mini = 6.

(d) À chaque étape, mini garde la plus petite valeur rencontrée jusque-là. À la fin du parcours, c’est donc le minimum global.

Réponses : (a) 6 ; (b) algorithme ci-dessus ; (c) 6 ; (d) car on garde le plus petit élément vu jusqu’ici.

(a) Oui, 9 est présente dans la liste.

(b) Non, 8 n’est pas présente.

(c) On peut écrire :

x = 9
trouve = False

for y in L:
    if y == x:
        trouve = True

(d) L’écriture rapide est 9 in L.

Réponses : (a) oui ; (b) non ; (c) algorithme ci-dessus ; (d) 9 in L.

(a) 18 est d’indice 2.

(b) 21 est d’indice 4.

(c) On peut écrire :

x = 18
indice = -1

for i in range(len(L)):
    if L[i] == x:
        indice = i

(d) Si la valeur n’est pas présente, on peut conserver indice = -1.

Réponses : (a) 2 ; (b) 4 ; (c) algorithme ci-dessus ; (d) garder -1.

(a) Les valeurs strictement supérieures à 10 sont 12, 17, 21 et 14. Il y en a donc 4.

(b) On peut écrire :

c = 0
for x in L:
    if x > 10:
        c = c + 1

(c) Il faut initialiser la variable c.

(d) On l’initialise à 0 car, avant le parcours, aucun élément n’a encore été compté.

Réponses : (a) 4 ; (b) algorithme ci-dessus ; (c) c ; (d) car on part d’aucun élément compté.

(a) La valeur 3 apparaît 3 fois.

(b) La valeur 7 apparaît 2 fois.

(c) On peut écrire :

x = 3
c = 0

for y in L:
    if y == x:
        c = c + 1

(d) Si la valeur n’est pas présente, le compteur reste à 0.

Réponses : (a) 3 ; (b) 2 ; (c) algorithme ci-dessus ; (d) 0.

(a) Les nombres pairs sont 8, 10, 12 et 18.

(b) On peut écrire :

pairs = []

for x in L:
    if x % 2 == 0:
        pairs.append(x)

(c) La nouvelle liste contient 4 éléments.

(d) On utilise append pour ajouter les éléments un par un à la fin de la nouvelle liste.

Réponses : (a) [8, 10, 12, 18] ; (b) algorithme ci-dessus ; (c) 4 ; (d) pour ajouter progressivement les éléments retenus.

(a) Les valeurs strictement positives sont 7, 5 et 9.

(b) On peut écrire :

positifs = []

for x in L:
    if x > 0:
        positifs.append(x)

(c) 0 n’est pas strictement positif, donc il n’est pas conservé.

(d) Il faudrait écrire la condition x >= 0.

Réponses : (a) [7, 5, 9] ; (b) algorithme ci-dessus ; (c) car 0 n’est pas strictement positif ; (d) x >= 0.

(a) Les carrés sont \(2^2=4\), \(4^2=16\), \(5^2=25\), \(7^2=49\). La liste cherchée est donc [4, 16, 25, 49].

(b) On peut écrire :

carres = []

for x in L:
    carres.append(x**2)

(c) L’instruction x**2 signifie « \(x\) au carré ».

(d) Pour les cubes, on remplacerait x**2 par x**3.

Réponses : (a) [4,16,25,49] ; (b) algorithme ci-dessus ; (c) carré ; (d) écrire x**3.

(a) Oui, tous les éléments de la liste sont strictement positifs.

(b) On peut écrire :

ok = True

for x in L:
    if x <= 0:
        ok = False

(c) Au début, ok vaut True.

(d) Si un élément négatif ou nul apparaît, alors ok devient False.

Réponses : (a) oui ; (b) algorithme ci-dessus ; (c) True ; (d) ok devient False.

(a) L[1:4] contient les éléments d’indices 1, 2 et 3, donc [4, 6, 8].

(b) L[:3] donne [2, 4, 6].

(c) L[3:] donne [8, 10, 12].

(d) L’indice final est exclu par convention Python : cela permet des découpages propres et facilite les calculs de longueur.

Réponses : (a) [4,6,8] ; (b) [2,4,6] ; (c) [8,10,12] ; (d) car l’indice final est exclu par convention.

(a) La liste triée dans l’ordre croissant est [3, 5, 7, 8, 10].

(b) Pour obtenir une copie triée, on écrit sorted(L).

(c) Pour trier directement la liste, on écrit L.sort().

(d) sorted(L) ne modifie pas la liste d’origine ; L.sort() modifie L elle-même.

Réponses : (a) [3,5,7,8,10] ; (b) sorted(L) ; (c) L.sort() ; (d) copie triée vs modification sur place.

(a) L’accès direct à L[i] est en \(O(1)\) : on accède directement à la position demandée.

(b) Un parcours complet est en \(O(n)\) car on lit les \(n\) éléments.

(c) Une recherche simple est en \(O(n)\) car, dans le pire des cas, il faut parcourir toute la liste.

(d) Le maximum est en \(O(n)\) car il faut comparer tous les éléments pour être certain de ne pas en manquer un plus grand.

Réponses : (a) \(O(1)\) ; (b) \(O(n)\) ; (c) \(O(n)\) ; (d) car il faut examiner toute la liste.

(a) La somme vaut \(12+7+18+5+9+14+21+8 = 94\).

(b) La liste contient 8 éléments, donc la moyenne vaut \(\dfrac{94}{8}=11{,}75\).

(c) Le maximum est 21 et le minimum est 5.

(d) Les éléments pairs sont 12, 18, 14 et 8. On peut écrire :

pairs = []

for x in L:
    if x % 2 == 0:
        pairs.append(x)

On obtient alors [12, 18, 14, 8].

Réponses : (a) 94 ; (b) 11,75 ; (c) max = 21, min = 5 ; (d) algorithme ci-dessus et liste [12, 18, 14, 8].