Ch0 – Algorithmique et Python – Exercices

🟢 Groupe 1 — Variables et calculs de base ▾

1

Prédire le résultat. Base

Sans exécuter le programme, indiquer ce qui est affiché à l’écran.

a = 7 b = 3 print(a + b) print(a * b) print(a // b) print(a % b) print(a ** b)

• 10 · 21 · 2 · 1 · 343
• \(7 + 3 = 10\) · \(7 \times 3 = 21\) · \(7 \div 3 = 2\) reste \(1\) · \(7^3 = 343\)

2

Aire et périmètre d’un cercle. Base

Écrire un programme qui demande le rayon \(r\) d’un cercle et affiche son périmètre \(2\pi r\) et son aire \(\pi r^2\), arrondis à 2 décimales.

import math r = float(input(" Rayon : ")) périmètre = 2 * math.pi * r aire = math.pi * r**2 print(" Périmètre = ", round(périmètre, 2)) print(" Aire = ", round(aire, 2))

3

Conversion d’unités. Base

Écrire un programme qui demande une température en degrés Celsius et l’affiche en degrés Fahrenheit. Formule : \(F = \dfrac{9}{5} C + 32\).

C = float(input(" Température en °C : ")) F = (9 / 5) * C + 32 print(" En Fahrenheit : ", F)

🔵 Groupe 2 — Instructions conditionnelles ▾

4

Parité. Base

Écrire une fonction est_pair(n) qui renvoie True si \(n\) est pair, False sinon. Tester avec plusieurs valeurs.

def est_pair(n): return n % 2 == 0 print(est_pair(4)) # True print(est_pair(7)) # False

5

Signe et valeur absolue. Intermédiaire

Écrire une fonction valeur_absolue(x) sans utiliser abs() ni opérateur ternaire, qui renvoie \(|x|\). Vérifier avec \(x = -5\), \(x = 3\), \(x = 0\).

def valeur_absolue(x): if x >= 0: return x else: return -x

6

Maximum de trois nombres. Intermédiaire

Écrire une fonction maximum3(a, b, c) qui renvoie le plus grand des trois réels \(a\), \(b\), \(c\) sans utiliser max().

def maximum3(a, b, c): if a >= b and a >= c: return a elif b >= c: return b else: return c

🟣 Groupe 3 — Boucles ▾

7

Table de multiplication. Base

Écrire un programme qui affiche la table de multiplication de 7 (de 7×1 à 7×10).

for i in range(1, 11): print(f" 7 × {i} = {7 * i} ")

8

Puissance de 2 et seuil. Intermédiaire

Un grain de riz est posé sur la case 1 d’un échiquier. Chaque case suivante contient le double du précédent. Écrire un programme qui calcule le nombre total de grains de riz sur un échiquier de 64 cases.

total = 0 grains = 1 for case in range(64): total += grains grains *= 2 print(" Total : ", total) # Ou plus court : 2**64 - 1

Total : \(2^{64} - 1 = 18\,446\,744\,073\,709\,551\,615\) grains !

9

Conjecture de Syracuse. Approfondissement

La suite de Syracuse est définie par : si \(u_n\) est pair alors \(u_{n+1} = u_n / 2\) ; sinon \(u_{n+1} = 3u_n + 1\). Écrire un programme qui, à partir d’un entier \(n\) saisi, affiche tous les termes jusqu’à atteindre 1 et compte le nombre d’etapes.

n = int(input(" n = ")) etapes = 0 while n != 1: print(n, end=" → ") if n % 2 == 0: n = n // 2 else: n = 3 * n + 1 etapes += 1 print(1) print(" Nombre d’etapes : ", etapes)

🔴 Groupe 4 — Fonctions et listes ▾

10

Moyenne et écart-type. Intermédiaire

Écrire deux fonctions : moyenne(L) et ecart_type(L) calculant la moyenne \(\bar{x}\) et l’écart-type \(\sigma = \sqrt{\dfrac{\sum(x_i - \bar{x})^2}{n}}\) d’une liste de nombres.

import math def moyenne(L): return sum(L) / len(L) def ecart_type(L): m = moyenne(L) variance = sum((x - m)**2 for x in L) / len(L) return math.sqrt(variance) notes = [12, 14, 9, 17, 11] print(moyenne(notes)) # 12.6 print(ecart_type(notes)) # ≈ 2.73

11

Crible d’Ératosthène. Approfondissement

Le crible d’Ératosthène est un algorithme pour trouver tous les nombres premiers jusqu’à \(N\). Principe : on commence avec une liste de tous les entiers de 2 à \(N\), puis on raye les multiples de chaque entier non encore rayé. Implémenter cet algorithme en Python et afficher tous les premiers jusqu’à 50.

def crible(N): premiers = [True] * (N + 1) premiers[0] = premiers[1] = False for p in range(2, int(N**0.5) + 1): if premiers[p]: for m in range(p*p, N+1, p): premiers[m] = False return [i for i in range(2, N+1) if premiers[i]] print(crible(50)) # [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47]

12

Recherche dichotomique. Approfondissement

On cherche un entier \(x\) compris entre 1 et 100 choisi au hasard. À chaque essai, l’ordinateur indique « plus petit » ou « plus grand ». La dichotomie consiste, à chaque étape, à proposer le milieu de l’intervalle courant.

Écrire en Python une fonction deviner(x) qui utilise la dichotomie pour trouver \(x\) et renvoie le nombre d’essais. L’intervalle de départ est \([1\,;\,100]\).
Tester avec \(x = 42\), \(x = 1\), \(x = 100\). Combien d’essais au maximum pour un entier dans \([1\,;\,100]\) ? Justifier.
Combien d’essais au maximum dans \([1\,;\,10^6]\) ?

1. Principe : on maintient \([bas\,;\,haut]\) et on divise l’intervalle par 2 à chaque étape.

def deviner(x): bas, haut = 1, 100 essais = 0 while bas <= haut: essais += 1 milieu = (bas + haut) // 2 if milieu == x: return essais elif milieu < x: bas = milieu + 1 else: haut = milieu - 1 return -1 # x hors intervalle print(deviner(42)) # 7 print(deviner(1)) # 6 print(deviner(100)) # 7

2. À chaque étape, l’intervalle est divisé par 2. Pour 100 entiers, il faut au plus \(\lceil \log_2(100) \rceil = 7\) essais (car \(2^6 = 64 < 100 \leqslant 128 = 2^7\)).

3. Pour \(10^6\) entiers, \(\lceil \log_2(10^6) \rceil = 20\) essais au maximum (car \(2^{19} \approx 524\,000\) et \(2^{20} \approx 1{,}05 \cdot 10^6\)). Bien plus rapide qu’une recherche séquentielle qui ferait jusqu’à \(10^6\) essais !

🟠 Entraînement WIMS — Exercices interactifs ▾

W

Exercices interactifs sur la plateforme WIMS.

🎯 S’entraîner sur Wims →

Chapitre 0 — Algorithmique et Python · Exercices