Corrections expliquées.
Algorithmique et programmation.

Correction D1

On applique les affectations dans l’ordre : $$x=4\quad\longrightarrow\quad x=2\times4=8 \quad\longrightarrow\quad x=8-3=5 \quad\longrightarrow\quad x=5^2=25.$$ La valeur finale est donc $\boxed{25}$. À chaque flèche, l’ancienne valeur est remplacée.

Correction D2

Correction D3

Correction D4

La fonction renvoie la valeur $7$ à l’endroit où elle est appelée. Elle ne renvoie pas le texte « return 7 ».

Correction D5

Les indices Python commencent à $0$. Le premier élément $12$ a donc l’indice $\boxed{0}$.

Correction D6

Si la condition d’une boucle reste toujours vraie, et si aucune instruction ne la rend fausse, la boucle peut continuer indéfiniment. Il faut vérifier qu’une variable évolue vers la condition d’arrêt.

Correction 1 — 1

On part de $x=4$. $$\begin{array}{c|c} \text{instruction}&\text{valeur de }x\\ \hline \text{initialisation}&4\\ x\leftarrow2x&8\\ x\leftarrow x-3&5\\ x\leftarrow x^2&25 \end{array}$$ La valeur finale est $\boxed{25}$.

Correction 2 — 2

Une solution complète est :

def signe_nombre(x):
    if x > 0:
        return 1
    elif x < 0:
        return -1
    else:
        return 0

Le premier test traite les positifs. Le second ne se fait que si le premier est faux ; le dernier cas est alors exactement $x=0$.

Correction 3 — 3

On initialise la somme à zéro, puis on ajoute les trois éléments : $$0+3=3,\qquad3+(-1)=2,\qquad2+4=\boxed6.$$ Par exemple :

def somme_liste(valeurs):
    total = 0
    for valeur in valeurs:
        total = total + valeur
    return total

L’initialisation à zéro est adaptée car zéro est l’élément neutre de l’addition.

Correction 4 — 4

Une solution par boucle est :

def doubles_positifs(valeurs):
    resultat = []
    for valeur in valeurs:
        if valeur > 0:
            resultat.append(2 * valeur)
    return resultat

Pour $[-2,3,4,0]$, seules $3$ et $4$ sont strictement positives, donc le résultat est $\boxed{[6,8]}$. Le zéro est exclu par « strictement ».

Correction 5 — 5

On teste la longueur avant de diviser :

def moyenne(valeurs):
    if len(valeurs) == 0:
        return None
    total = 0
    for valeur in valeurs:
        total = total + valeur
    return total / len(valeurs)

Pour la liste vide, la fonction renvoie $\boxed{\texttt{None}}$, car une division par zéro n’est pas définie. Pour $[4,6]$, elle calcule $$\frac{4+6}{2}=\boxed5.$$

Correction 6 — 6

La boucle parcourt $1,2,3,4$. Le reste de la division par $2$ vaut zéro pour les nombres pairs : $$2\mathbin{\%}2=0,\qquad4\mathbin{\%}2=0.$$ Les valeurs ajoutées sont donc $2$ et $4$, et le programme renvoie $\boxed{[2,4]}$. Le symbole % calcule le reste de la division euclidienne.

Correction 7 — 7

Une fonction possible est :

def premier_carre(limite):
    n = 0
    while n <= limite and n*n < 50:
        n = n + 1
    if n <= limite:
        return n
    return None

Les carrés sont $0^2,\ldots,7^2$, et $7^2=49<50$. Le rang suivant vaut $8$, et $8^2=64\geq50$. Le résultat est donc $\boxed8$. Le test de n <= limite prévoit le cas où aucun rang ne convient.

Correction 8 — 8

On peut écrire :

from random import random

def frequence_piles():
    piles = 0
    for i in range(1000):
        if random() < 0.5:
            piles = piles + 1
    return piles / 1000

La valeur renvoyée est la fréquence observée de piles dans une réalisation de $1000$ lancers. Elle devrait souvent être proche de $0{,}5$, mais elle peut être $0{,}476$, $0{,}503$ ou une autre valeur : aucune valeur exacte n’est imposée par la simulation.

Correction R1

Correction R2

Correction R3

Zéro est l’élément neutre de l’addition : $$0+a=a.$$ Une somme peut donc commencer à zéro sans modifier le résultat. Chaque élément sera ensuite ajouté exactement une fois.

Correction R4

On peut tester moyenne([4,6]), dont le résultat attendu est $5$. On peut aussi tester une liste constante comme $[7,7,7]$, dont la moyenne doit être $7$, ou la liste vide si le programme prévoit ce cas.