Exercices – Chapitre 7

Exercice 1 — Lire et prédire la sortie

Que renvoie ce programme ?

s = 0
for k in range(1, 5):
    s = s + k
print(s)

Exercice 2 — Prédire la sortie d'une compréhension

Que contient la liste L ?

L = [3 * n for n in range(1, 6)]
print(L)

Exercice 3 — Compléter un programme

Compléter les pointillés pour que la fonction compte, dans une liste, le nombre de valeurs strictement supérieures à 10.

def compter_grands(L):
    c = ...                 # (a)
    for x in L:
        if ... :            # (b)
            c = ...          # (c)
    return c

print(compter_grands([5, 12, 8, 20, 10, 15]))   # doit afficher 3

Exercice 4 — Corriger un programme

Ce programme doit calculer le produit des entiers de 1 à 4 (soit \(4!=24\)), mais il renvoie 0. Trouver et corriger l'erreur.

p = 0
for k in range(1, 5):
    p = p * k
print(p)

Exercice 5 — Traduire un algorithme (seuil)

Traduire en Python l'algorithme suivant, qui cherche le plus petit entier \(n\) tel que \(3^n\) dépasse 500.

n ← 0
Tant que 3^n ≤ 500 :
    n ← n + 1
Afficher n

n = 0
while 3 ** n <= 500:
    n = n + 1
print(n)              # affiche 6  (3**6 = 729, 3**5 = 243)

Exercice 6 — Fonction et compréhension

1. Écrire une fonction est_pair(n) qui renvoie True si n est pair, False sinon.

2. Utiliser une compréhension pour construire la liste des multiples de 5 compris entre 0 et 40 inclus.

def est_pair(n):
    return n % 2 == 0

multiples = [x for x in range(41) if x % 5 == 0]
print(multiples)      # [0, 5, 10, 15, 20, 25, 30, 35, 40]

Exercice 7 — Suite par récurrence

Soit la suite définie par \(u(0)=3\) et \(u(n+1)=2\,u(n)-1\).

1. Compléter l'algorithme en langage naturel qui calcule \(u(5)\).

u ← 3
Pour i allant de 1 à 5 :
    u ← 2 × u − 1
Afficher u

2. Le traduire en Python et donner la valeur affichée.

u = 3
for i in range(1, 6):     # i prend 1, 2, 3, 4, 5
    u = 2 * u - 1
print(u)                  # affiche 65

Exercice 8 — Problème type : simuler une loi de Bernoulli

On veut simuler \(n=100\) épreuves de Bernoulli de paramètre \(p=0{,}3\) et compter le nombre de succès (issue codée \(1\)).

1. Écrire une fonction bernoulli(p) qui renvoie \(1\) avec probabilité \(p\), \(0\) sinon.

2. Construire un échantillon de taille 100 dans une liste, puis compter les succès de deux façons (avec un compteur, puis avec sum).

3. Autour de quelle valeur le nombre de succès devrait-il se situer ? Pourquoi ?

from random import random

def bernoulli(p):
    return 1 if random() < p else 0

# 2a. avec un compteur
succes = 0
for i in range(100):
    if bernoulli(0.3) == 1:
        succes = succes + 1
print(succes)

# 2b. avec sum sur une liste (compréhension)
echantillon = [bernoulli(0.3) for _ in range(100)]
print(sum(echantillon))