Chapitres de Première

Algorithmique et programmation — Notion de liste

1
Exercice 1
Facile
On considère les instructions Python suivantes :
```
L = [3, 8, 5, 1, 9, 4]
```
1. Que renvoie L[0] ? Que renvoie L[2] ?
2. Que renvoie len(L) ?
3. Quel indice permet d'accéder au dernier élément de la liste ? Donner deux façons de l'écrire.
4. Que renvoie L[1:4] ?
5. Écrire une instruction qui remplace le troisième élément de la liste par la valeur $7$ .
Voir un indice
Les indices d'une liste commencent à $0$ . Le dernier élément d'une liste de longueur $n$ a pour indice $n-1$ , ou encore l'indice $-1$ . La tranche L[a:b] contient les éléments d'indices $a$ à $b-1$ .
Voir la correction
1. L[0] renvoie $3$ (premier élément, indice $0$ ). L[2] renvoie $5$ (troisième élément, indice $2$ ).
2. len(L) renvoie $6$ : la liste contient six éléments.
3. Le dernier élément a pour indice $5$ , c'est-à-dire len(L) - 1. On peut aussi l'écrire L[-1], qui renvoie $4$ .
4. L[1:4] renvoie la sous-liste des éléments d'indices $1$ , $2$ et $3$ , soit [8, 5, 1]. L'élément d'indice $4$ n'est pas inclus.
5. Le troisième élément a pour indice $2$ . On écrit :
```
L[2] = 7
```
Après cette instruction, L vaut [3, 8, 7, 1, 9, 4].
2
Exercice 2
Facile
Construire une liste peut se faire de plusieurs manières. Pour chacune des questions suivantes, donner la liste finale obtenue.
1. En extension. On écrit A = [1, 4, 9, 16, 25]. Que contient A ?
2. Par ajouts successifs. On exécute :
```
B = []
for k in range(1, 6):
    B.append(k * k)
```
Que contient B à la fin ?
1. En compréhension. On écrit C = [k * k for k in range(1, 6)]. Que contient C ?
2. Comparer les trois listes obtenues.
Voir un indice
range(1, 6) parcourt les entiers $1, 2, 3, 4, 5$ (la borne $6$ est exclue). La méthode append ajoute un élément à la fin d'une liste. Une liste en compréhension [expression for k in ...] calcule l'expression pour chaque valeur de $k$ .
Voir la correction
1. A contient les cinq valeurs écrites directement : [1, 4, 9, 16, 25].
2. On part de la liste vide B = []. La boucle parcourt $k = 1, 2, 3, 4, 5$ et ajoute à chaque fois $k^2$ :
- $k=1$ : on ajoute $1$ , donc B = [1] ; 1. $k=2$ : on ajoute $4$ , donc B = [1, 4] ; 1. $k=3$ : on ajoute $9$ , donc B = [1, 4, 9] ; 1. $k=4$ : on ajoute $16$ , donc B = [1, 4, 9, 16] ; 1. $k=5$ : on ajoute $25$ , donc B = [1, 4, 9, 16, 25].
1. La compréhension calcule $k^2$ pour $k$ de $1$ à $5$ , donc C = [1, 4, 9, 16, 25].
2. Les trois listes sont identiques : A, B et C valent toutes [1, 4, 9, 16, 25]. Ce sont trois façons différentes de construire la liste des carrés des entiers de $1$ à $5$ .
3
Exercice 3
Facile
On donne la liste notes = [12, 8, 15, 6, 18, 11].
1. Écrire une boucle for qui parcourt la liste et affiche chaque note.
2. Écrire une fonction somme(L) qui renvoie la somme des éléments d'une liste L de nombres, en initialisant un accumulateur à $0$ et en le mettant à jour dans une boucle.
3. En déduire une fonction moyenne(L) qui renvoie la moyenne des éléments de L.
4. Que renvoie moyenne(notes) ?
Voir un indice
Pour parcourir les éléments d'une liste, on peut écrire for x in L:. Pour la somme, on utilise une variable accumulateur s initialisée à $0$ , à laquelle on ajoute chaque élément. La moyenne est la somme divisée par le nombre d'éléments len(L).
Voir la correction
1. On itère directement sur les éléments :
```
for note in notes:
    print(note)
```
Cela affiche successivement $12$ , $8$ , $15$ , $6$ , $18$ , $11$ . 1.
```
def somme(L):
    s = 0
    for x in L:
        s = s + x
    return s
```
```
def moyenne(L):
    return somme(L) / len(L)
```
1. La somme des notes est $12 + 8 + 15 + 6 + 18 + 11 = 70$ , et il y a $6$ notes. Donc moyenne(notes) renvoie $70 / 6 \approx 11{,}67$ .
4
Exercice 4
Facile
On veut construire, à partir d'une liste, une nouvelle liste ne contenant que certains éléments.
1. Écrire, en compréhension, la liste pairs des entiers pairs de $0$ à $20$ inclus.
2. Écrire, en compréhension, à partir de L = [7, 2, 9, 4, 5, 12, 3], la liste des éléments de L strictement supérieurs à $5$ .
3. Écrire une fonction compte_positifs(L) qui renvoie le nombre d'éléments strictement positifs d'une liste L.
4. Tester la fonction avec L = [-3, 4, 0, 7, -1, 2].
Voir un indice
Une compréhension avec condition s'écrit [x for x in L if condition]. Pour les entiers pairs, on peut utiliser range(0, 21, 2) ou une condition k % 2 == 0. Pour compter, on incrémente un compteur dans une boucle.
Voir la correction
1. Deux écritures possibles :
```
pairs = [k for k in range(0, 21) if k % 2 == 0]
```
ou plus directement pairs = [k for k in range(0, 21, 2)]. Dans les deux cas :
```
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
```
```
grands = [x for x in L if x > 5]
```
On garde les éléments strictement supérieurs à $5$ : grands vaut [7, 9, 12]. 1.
```
def compte_positifs(L):
    c = 0
    for x in L:
        if x > 0:
            c = c + 1
    return c
```
1. Avec L = [-3, 4, 0, 7, -1, 2], les éléments strictement positifs sont $4$ , $7$ et $2$ . Donc compte_positifs(L) renvoie $3$ . Attention : $0$ n'est pas strictement positif et n'est pas compté.
5
Maximum d'une liste en Python
Moyen
On souhaite déterminer le maximum d'une liste de nombres sans utiliser la fonction max de Python.
1. Écrire une fonction maximum(L) qui renvoie le plus grand élément d'une liste L non vide. On initialisera une variable avec le premier élément L[0], puis on parcourra la liste.
2. Dérouler l'exécution (trace) de maximum([4, 9, 2, 11, 7]) en indiquant la valeur de la variable qui stocke le maximum à chaque étape.
3. Modifier la fonction pour qu'elle renvoie l'indice d'un plus grand élément plutôt que sa valeur.
Voir un indice
On stocke le maximum courant dans une variable m initialisée à L[0]. On compare chaque élément à m et on met m à jour s'il est plus grand. Pour l'indice, on parcourt les indices avec range(len(L)) et on mémorise l'indice du maximum.
Voir la correction
Ce contenu est réservé : laisse tes coordonnées pour débloquer toutes les indications et corrections du site, gratuitement.
Tes coordonnées servent uniquement à t'informer de nos ressources et stages — jamais de spam. Politique de confidentialité
6
Traitement d'une liste de consommations
Moyen
Une entreprise relève chaque jour de la semaine (du lundi au vendredi) sa consommation d'électricité, en kWh, dans une liste :
```
conso = [120, 135, 128, 142, 118]
```
1. Écrire une instruction qui ajoute à la liste la consommation du samedi, égale à $95$ kWh.
2. Écrire une fonction total(L) renvoyant la consommation totale de la semaine.
3. Écrire une fonction jours_au_dessus(L, seuil) qui renvoie la liste des indices des jours où la consommation dépasse strictement seuil.
4. Que renvoie jours_au_dessus(conso, 125) après l'ajout du samedi ?
5. On s'est trompé : la valeur du mercredi (indice $2$ ) doit être $130$ et non $128$ . Écrire l'instruction qui corrige cette valeur.
Voir un indice
append ajoute un élément en fin de liste. Pour renvoyer des indices, on parcourt range(len(L)) et on ajoute i à une liste résultat quand la condition est vérifiée. On accède à un élément par son indice pour le modifier.
Voir la correction
Ce contenu est réservé : laisse tes coordonnées pour débloquer toutes les indications et corrections du site, gratuitement.
Tes coordonnées servent uniquement à t'informer de nos ressources et stages — jamais de spam. Politique de confidentialité
7
Suppression de valeurs dans une liste
Moyen
On dispose d'une liste de nombres et on veut supprimer certains de ses éléments.
1. On exécute :
```
L = [5, 8, 3, 8, 6, 8, 2]
L.remove(8)
```
Que contient L après cette instruction ? La méthode remove supprime-t-elle toutes les occurrences de $8$ ?
1. On veut construire une nouvelle liste sans les valeurs égales à $8$ . Écrire, en compréhension, la liste M des éléments de L = [5, 8, 3, 8, 6, 8, 2] différents de $8$ .
2. Écrire une fonction sans_valeur(L, v) qui renvoie une nouvelle liste contenant les éléments de L différents de v, sans modifier L.
3. Piège. On propose le code suivant pour supprimer tous les $8$ :
```
L = [5, 8, 3, 8, 6, 8, 2]
for i in range(len(L)):
    if L[i] == 8:
        L.remove(8)
```
Expliquer pourquoi ce code provoque une erreur ou un résultat incorrect.
Voir un indice
remove(v) ne supprime que la première occurrence de v. Modifier une liste (en supprimant des éléments) pendant qu'on la parcourt par indices change sa longueur et décale les éléments : les indices ne correspondent plus. La compréhension [x for x in L if x != v] construit une liste sans toucher à l'originale.
Voir la correction
Ce contenu est réservé : laisse tes coordonnées pour débloquer toutes les indications et corrections du site, gratuitement.
Tes coordonnées servent uniquement à t'informer de nos ressources et stages — jamais de spam. Politique de confidentialité
8
Exercice 8
Difficile
On appelle crible d'Ératosthène un algorithme qui détermine tous les nombres premiers inférieurs ou égaux à un entier $n$ . Le principe : on part de la liste de tous les entiers de $2$ à $n$ , puis on élimine progressivement les multiples de chaque nombre premier trouvé.
1. Écrire une fonction est_premier(n) qui teste si un entier n $\geq 2$ est premier, en cherchant un diviseur entre $2$ et $n-1$ .
2. En déduire, en compréhension, la liste des nombres premiers inférieurs ou égaux à $30$ .
3. Proposer une implémentation du crible utilisant une liste de booléens est_prem de taille $n+1$ , où est_prem[k] indique si $k$ est premier. Renvoyer la liste des indices k tels que est_prem[k] est True.
4. Vérifier que les deux méthodes donnent la même liste pour $n = 30$ .
Voir un indice
Ce contenu est réservé : laisse tes coordonnées pour débloquer toutes les indications et corrections du site, gratuitement.
Tes coordonnées servent uniquement à t'informer de nos ressources et stages — jamais de spam. Politique de confidentialité
Voir la correction
Ce contenu est réservé : laisse tes coordonnées pour débloquer toutes les indications et corrections du site, gratuitement.
Tes coordonnées servent uniquement à t'informer de nos ressources et stages — jamais de spam. Politique de confidentialité
9
Exercice 9
Difficile
On s'intéresse à la manipulation avancée des indices et à la construction de listes de listes.
1. Écrire une fonction inverse(L) qui renvoie une nouvelle liste contenant les éléments de L dans l'ordre inverse, sans utiliser L[::-1] ni reversed. On parcourra les indices de la fin vers le début.
2. Une liste peut contenir des listes. On considère la « matrice »
```
M = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
```
Que renvoie M[1] ? Que renvoie M[1][2] ?
1. Écrire, à l'aide d'une double boucle, une fonction somme_matrice(M) qui renvoie la somme de tous les nombres d'une telle liste de listes.
2. Écrire, en compréhension imbriquée, la liste diagonale des éléments M[i][i] pour i allant de $0$ à $2$ . Que vaut-elle ?
3. Ouverture. Écrire, en compréhension imbriquée, la table de multiplication $3 \times 3$ , c'est-à-dire la liste de listes dont l'élément de la ligne i et de la colonne j vaut (i+1)*(j+1).
Voir un indice
Ce contenu est réservé : laisse tes coordonnées pour débloquer toutes les indications et corrections du site, gratuitement.
Tes coordonnées servent uniquement à t'informer de nos ressources et stages — jamais de spam. Politique de confidentialité
Voir la correction
Ce contenu est réservé : laisse tes coordonnées pour débloquer toutes les indications et corrections du site, gratuitement.
Tes coordonnées servent uniquement à t'informer de nos ressources et stages — jamais de spam. Politique de confidentialité

Algorithmique et programmation — Notion de liste

Exercice 1

Exercice 2

Exercice 3

Exercice 4

Maximum d'une liste en Python

Traitement d'une liste de consommations

Suppression de valeurs dans une liste

Exercice 8

Exercice 9