Algorithmique et programmation | Première générale (spécialité) | Mathématiques
Dernière mise à jour : 21 octobre 2026
L = [4, 9, 16], indices à partir de \(0\), dernier élément L[-1], taille len(L) ; range(n) parcourt \(0, \dots, n-1\) ; append ajoute en fin ; while répète tant qu'une condition est vraie.
On considère la liste L = [6, 2, 9, 4, 7].
1. Donner les valeurs de L[0], L[3], L[-1] et len(L). (2 pts)
2. Écrire l'instruction qui ajoute la valeur \(5\) à la fin de L. (1 pt)
3. Que renvoie le code suivant ? Justifier. (2 pts)
s = 0
for x in L:
if x % 2 == 0:
s += x
print(s)4. Par compréhension, écrire la liste des éléments de L strictement supérieurs à \(5\). (2 pts)
1. L[0] \(= 6\), L[3] \(= 4\), L[-1] \(= 7\), len(L) \(= 5\).
2. L.append(5).
3. On additionne les éléments pairs : \(6\), \(2\) et \(4\), soit \(6 + 2 + 4 = 12\). Le code affiche 12. (La question 2 n'ayant pas modifié L ici, on utilise la liste initiale.)
4. [x for x in L if x > 5], ce qui donne [6, 9, 7].
1. Écrire une fonction compte_positifs(L) qui renvoie le nombre d'éléments strictement positifs d'une liste. (2,5 pts)
2. Écrire une fonction maximum(L) qui renvoie le plus grand élément d'une liste non vide, sans utiliser max. (2,5 pts)
3. On donne L = [-2, 5, 3, -1, 8]. Que renvoient compte_positifs(L) et maximum(L) ? (2 pts)
1. On incrémente un compteur pour chaque élément \(> 0\) :
def compte_positifs(L):
c = 0
for x in L:
if x > 0:
c += 1
return c2. On part du premier élément et on garde le plus grand :
def maximum(L):
m = L[0]
for x in L:
if x > m:
m = x
return m3. Les positifs sont \(5\), \(3\), \(8\) : compte_positifs(L) renvoie \(3\). Le plus grand élément est \(8\) : maximum(L) renvoie \(8\).
On étudie la suite \(u_0 = 5\), \(u_{n+1} = 2u_n + 1\).
1. Écrire une fonction termes(n) renvoyant la liste des \(n\) premiers termes de la suite. (3 pts)
2. Donner la liste renvoyée par termes(4). (1,5 pt)
3. Écrire une fonction rang_seuil(S) renvoyant le premier rang \(n\) tel que \(u_n \geqslant S\). (1,5 pt)
1. On ajoute chaque terme à partir du dernier :
def termes(n):
L = [5] # u_0
for _ in range(n - 1):
L.append(2 * L[-1] + 1)
return L2. \(u_0 = 5\), \(u_1 = 11\), \(u_2 = 23\), \(u_3 = 47\). La liste est [5, 11, 23, 47].
3. On répète tant que \(u \lt S\) :
def rang_seuil(S):
u, n = 5, 0
while u < S:
u = 2 * u + 1
n += 1
return n