ALGORITHMIQUE ET PROGRAMMATION AVEC PYTHON - Les suites

Rappel : un algorithme est une suite finie d’instructions à appliquer dans un ordre déterminé, à un nombre
fini de données pour arriver, en un nombre fini d’étapes, à un certain résultat.

Programmer un algorithme, c’est le traduire dans un langage compréhensible par un logiciel donné, sur un ordi-
nateur ou une calculatrice. Cette année, nous allons utiliser le langage de programmation PYTHON.
Ouvrir EduPython. Dans cet environnement, on dispose :
• d’une zone de script : c’est là qu’on écrit le programme ; les lignes sont numérotées. ne pas oublier de l’exé-
cuter à la fin grâce à flèche verte ou Run pour valider ou corriger les erreurs indiquées dans la console :
• d’une console interactive : c’est la zone d’interactivité avec l’utilisateur qui écrit des instructions et les exécute.

Quelques bonnes pratiques à adopter :

• donner des noms évocateurs aux objets utilisés pour mieux identifier leur rôle
• Sauter des lignes pour mettre en valeur la structure du programme ou pour départager des programmes
• Mettre des commentaires à l’aide d’un texte précédé de # pour expliquer ce que l’on fait
• Enregistrer régulièrement son fichier
A : Fonction en Python
Exemple 1 : : Code Python :
À quoi sert cet algorithme ? taper le code dans la zone script puis l’exécuter. def carre(a) :
Écrire carre(3) dans la console et taper Entrer. Tester avec d’autres nombres. return a∗∗ 2

À retenir : en langage Python, on définit une fonction par la commande def suivi du nom de la fonction
(ici "carre"), puis de son ou ses argument(s) (la variable) nommé ici a (l’habituel x), suivi de deux points.
Une fois le code Python de cette fonction exécuté, on se contente d’écrire dans la console : carre(5) pour
avoir l’image de 5 par la fonction carre.
Remarque importante : l’exécution de return résultat a deux effets :
• renvoyer le ou les résultats obtenus
• terminer l’exécution des instructions qui définissent la fonction

Exemple 2 : calculer un terme d’une suite définie par une formule explicite :

Soit (un ) la suite définie par : un = 5 − 2n pour tout entier n de N.

def u(n) :
1. Écrire le code Python ci-contre dans le script puis exécuter. return 5 − 2 ∗ n
2. Écrire u(1) puis u(10) dans la console. Vérifier avec la question 1.

B. Boucle for ... en Python : boucle bornée pour répéter quand on connaît le nombre de répétitions
Pour i allant de m à n La variable i contrôle le nombre de répétitions.
for i in range (m, n + 1) : La variable i parcourt tous les entiers de m à n.
| instructions
Fin Pour
instructions Si m commence à 0, on peut remplacer range (m, n + 1)
par range (n + 1)
En langage Python :
• le mot clé for introduit la boucle
• les deux points à la fin de la 1ère ligne marquent le début du bloc d’instructions à répéter
• pas de fin de boucle for : seul le retour vers la gauche par rapport à l’indentation précédente marque la
sortie de la boucle (Fin Pour)
Différentes syntaxes à connaître :

for i in ... i prend successivement les valeurs entières ...

range(5) de 0 à 4 donc 0, 1, 2, 3, 4 (attention : 5 est exclu !)
range(2, 8) de 2 à 7 donc 2, 3, 4, 5, 6, 7 ( attention 8 est exclu !)
range(10, 17, 2) de 10 à 16 mais de 2 en 2 donc 10, 12, 14, 16
Exemple 3 : calculer un terme d’une suite définie par récurrence :
Soit (un ) la suite définie par : u0 = 3 et un+1 = 2un − 1 pour tout n de N.
1. Calculer mentalement u1 , u2 et u3 . def u(n) :
u=3
2. Compléter le programme en langage Python ci-contre pour qu’il renvoie for i in range (1, n + 1) :
un lorsque n est donné par l’utilisateur. u = ..........
3. Vérifier avec u1 , u2 et u3 puis utiliser ce programme pour calculer u10 . return u

Exemple 4 : calculer la somme des entiers consécutifs : 1 + 2 + .... + n. def Somentiers(n) :

S=0
1. Compléter le programme ci-contre pour qu’il renvoie cette somme.
for i in range (..... ) :
2. Le coder puis l’exécuter. S = S + .....
3. Le tester pour n = 10. return S

C. Boucle while ... en Python : boucle non bornée pour répéter quand on a une condition d’arrêt
Tant que condition C : Tant que la condition C est vraie, on répète
while condition C :
| instructions les instructions qui figurent dans le bloc
instructions
Fin Tant que indenté (décalé vers la droite).

def Seuil(S) :
Exemple 5 : déterminer un seuil u = ...
Soit (un ) la suite définie par : u0 = 3 et un+1 = 2un − 1 pour tout n de N. N = ...
1. Compléter le programme en Python ci-contre pour qu’il renvoie le plus while ........ :
petit entier N tel que un > S où S est donné par l’utilisateur. u = .....
2. Tester ce programme pour S = 100 puis S = 1000. N = .....
return N

D. Les listes en Python

Une liste se présente comme une suite d’éléments, séparés par des virgules. Une liste est écrite entre crochets.
Voici trois façons différentes pour créer la liste [0, 10, 20, 30].

L=[0, 10, 20, 30] on crée la liste en entrant chaque valeur à la main
Les éléments de la liste sont les produits 10 ∗ i quand i prend les valeurs
L=[10 ∗ i for i in range(4)] 0, 1, 2 et 3
L=[ ] On crée la liste vide [ ], puis on ajoute un par un les éléments.
for i in range(4) L.append(a) modifie la liste L en lui ajoutant à la fin l’élément a ;
L.append(10 ∗ i) la liste ainsi rallongée s’appelle toujours L.

Différentes syntaxes à connaître :

L[k − 1] Valeur du kième élément de la liste L

len(L) longueur de la liste L
L.append(a) Ajout de l’élément a en fin de liste L
L.pop(k) suppression de l’élément d’indice k de la liste L

Exemple 6 : Liste des termes d’une suite :

On reprend la suite de l’exemple 4 : soit (un ) la suite définie par : u0 = 3 et un+1 = 2un − 1 pour tout n de N.

def listeu(n) :
1. Coder le programme Python ci-contre.
u=3
2. Le tester pour n = 3 puis pour n = 6. L = [u]
3. Quel est le rôle de ce programme ? for i in range(n) :
4. Écrire une fonction plus courte qui donne le même résultat que listeu(n) u=2∗u−1
mais qui utilise la fonction de l’exemple 3. L.append(u)
return L
 ALGORITHMIQUE ET PROGRAMMATION AVEC PYTHON - Les suites
EXERCICES POUR S’ENTRAÎNER

Exercice 1 : tester les 2 programmes ci-dessous dans le script ; les exécuter puis observer l’affichage dans la console.
Que retenir ?

a=1 a=1
for i in range(2, 5) : for i in range(2, 5) :
a=i*a a=i*a
print(a) print(a)

Exercice 2 : calculer un terme d’une suite définie par récurrence :

On souhaite calculer des termes d’une suite (vn ) définie sur N.
1. Coder le programme ci-contre qui permet de calculer les termes vn . def v(n) :
v=4
2. Quelle est la valeur de v0 ? ..................
for k in range (n) :
3. Quelle est la relation de récurrence entre vn+1 et vn ? ............. v = v + 1/v
4. Utiliser ce programme pour calculer v2 puis v100 . return v

Exercice 3 : calculer un terme d’une suite définie par récurrence :

On souhaite calculer des termes d’une suite (wn ) définie sur N.
1. Coder le programme ci-contre qui permet de calculer les termes wn .
def w(n) :
2. Quelle est la valeur de w0 ? .................. w=5
3. Calculer w1 et w2 à la main. Vérifier avec le programme....... for k in range (1, n + 1) :
4. Quelle est la relation de récurrence entre wn+1 et wn ? ............. w = w + 3 ∗ (k − 1)
return w
5. Utiliser ce programme pour calculer w100 .

Exercice 4 : somme de termes consécutifs d’une suite arithmétique def Som2(n) :

Soit la suite arithmétique (un ) de premier terme u0 = −1 et de raison : r = 2. S=0
u = −1
1. Compléter le programme ci-contre pour qu’il calcule la somme des n + 1
for i in range (......) :
premiers termes de cette suite où n est un entier naturel fixé.
S = S + .....
2. Le coder, l’exécuter et le tester pour n = 10. (vérifier le résultat à la u = .....
main !) return S

Exercice 5 : Même question qu’à l’exercice précédent avec la somme des n + 1 premiers termes de la suite
1
géométrique (tn ) de premier terme t0 = −2 et de raison : q = .
2
Exercice 6 : déterminer un seuil
En 2020, Carole place 3000 e sur un compte à la banque.‘
Chaque début d’année, la somme disponible augmente de 2, 5 %. def SeuilCa(s) :
Carole souhaite écrire un programme en langage Python qui lui per- A = 2020
mette de savoir à partir de quelle année elle pourra disposer d’au p = 3000
moins 3500 e sur son compte. while p ...... :
A=A+1
1. Compléter le programme en Python ci-contre puis l’exécuter.
p = ............
2. Déterminer Seuil(3500). Interpréter le résultat. return A
3. Utiliser ce programme pour déterminer l’année à partir de la
laquelle son capital aura doublé.
Exercice 7 : Désintégration et seuil
L’iode 131 est un produit radioactif utilisé lors d’un examen médical appelé scintigraphie.
Sa demi-vie est de 8 jours. La demi-vie correspond à la durée pour laquelle la moitié des noyaux radioactifs d’un
échantillon se sont désintégrés. Un patient absorbe 10 000 noyaux d’iode 131.
On note un le nombre de noyaux radioactifs non désintégrés au bout de n demi-vies.
 1. Déterminer u0 . def iode(s) :
2. Écrire un+1 en fonction de un pour tout entier naturel n. u = .......
n=0
3. Compléter le programme ci-contre qui permet de connaître le nombre de while ............. :
demi-vies nécessaires pour qu’il ne reste plus que 625 noyaux radioactifs u = .....
dans le corps du patient. n = ...
4. Déterminer ce nombre de demi-vies. En déduire la valeur en jours. return u, n

Exercice 8 : Suite de Fibonacci : on doit à Fibonacci, mathématicien italien du XIIIe siècle le problème :
"Un homme met un couple de lapins dans un lieu clos. Combien de couples obtient-on en un an si chaque couple
engendre tous les mois un nouveau couple à compter du troisième mois de son existence ?"
On considère la suite (un ) définie pour tout entier n comme le nombre de couples présents le n-ième mois.

def fibonacci(n) :
On pose : u0 = 0 et u1 = 1 et pour tout entier naturel n, un+2 = un+1 + un . a=0
b=1
1. Déterminer les 6 premiers termes de cette suite à la main. L = [a]
for i in range(1, n + 1) :
2. Coder le programme Python ci-contre.
c=a
3. Le tester pour n = 6 puis pour n = 12. Quel est le rôle de ce programme ? a=b
4. Interpréter les résultats précédents dans le contexte du problème posé par b=c+b
Fibonacci. L.append(a)
return L

Exercice 9 : Factorielle n : def f ac(n) :

u=1
On appelle factorielle n et on note n! le produit de tous les entiers de 1 à n soit
for k in range (.....) :
n! = 1 × 2 × ... × n.
u = ..........
Par convention : 0! = 1
return u
1. Calculer à la main 2!, 3! , 4! puis 5!.
def seuilf ac() :
2. Compléter le programme ci-contre pour qu’il renvoie factorielle n. n=0
3. Vérifier les 4 calculs de la question 1. while 3∗∗ n > f ac(n) :
4. Écrire la fonction def seuilfac() ci-contre puis l’exécuter. n = n+1
Interpréter le résultat. return n

def liste(k) :
Exercice 10 : v = 0.5
1 1 L=[]
Soit (vn ) la suite définie par : v0 = et vn+1 = pour tout n de N.
2 vn + 1 for i in range (.....) :
Compléter la fonction ci-contre pour qu’elle renvoie la liste des termes de la suite L.append(round(v,3))
de v0 à vk arrondis à 3 chiffres après la virgule. v = .....
return L
Exercice 11
1 2wn
Soit (wn ) la suite définie par : w0 = et wn+1 = pour tout n de N. On donne trois fonctions Python :
2 1 + wn
def algo2(n) :
W = [1/2] def algo3(n) :
def algo1(n) : i=0 w = [1/2]
W =[] while len(W) != n : L = [w]
for k in range (.....) : W.append(2 ∗ W [i]/(1 + W [i])) for i in range(n) :
.......... i =i+1 w = 2 ∗ w/(1 + w)
return W return W L.append(round(w,2))
return L

1. Compléter la fonction algo1 pour que la liste retournée contienne les n premiers termes de la suite (vn ).
2. Quel est le rôle de la fonction algo2 ?
3. Quelle liste est retournée lors de l’appel de algo3(3) ?