Tapez les lignes suivantes dans l'interpréteur :

>>> for i in range(1, 10, 1):
        print("la variable de boucle 'i' vaut", i)

???

Remarque : comme l'instruction de boucle tient sur plusieurs lignes, l'interpréteur attend de voir une ligne blanche avant d'évaluer le bloc de code.

Recommencez en changeant le range(1, 10, 1) par d'autres valeurs :

• range(10, 1, 1),
• range(1, 10, 3),
• range(1, 10, -1),
• range(10, 1, -1),
• range(10, 10, 1),
• range(10, 10, 0)

et essayez de deviner à chaque fois ce que l'interpréteur affichera.

Écrivez, en utilisant une boucle for, une fonction compte_triangle avec un paramètre entier n qui compte le nombre d'étoiles dans un triangle de n lignes comme celui ci :

*
**
***
****
*****

Ce triangle contient 5 lignes et 15 étoiles au total. On aura donc

>>> compte_triangle(5)
15

Remarque : comme la ligne i contient exactement i étoiles, il s'agit en fait de la fonction qui calcule la somme des n premiers nombres entiers. Ces nombres sont appelés nombres triangulaires !

Ajoutez une ligne dans la fonction compte_triangle de la question précédente pour afficher les informations suivantes :

>>> compte_triangle(7)
ligne 1 il y a déjà eu 1 étoiles
ligne 2 il y a déjà eu 3 étoiles
ligne 3 il y a déjà eu 6 étoiles
ligne 4 il y a déjà eu 10 étoiles
ligne 5 il y a déjà eu 15 étoiles
ligne 6 il y a déjà eu 21 étoiles
ligne 7 il y a déjà eu 28 étoiles
28

Dans le calcul précédent, il faut bien distinguer les lignes contenant les informations affichées par le print et le résultat de la fonction, affiché par l'interpréteur (ici, le nombre 28). Les informations seront toujours affichées, même lorsqu'on utilise une variable pour stocker le résultat de la fonction.

Évaluez les expressions suivantes en essayant de deviner à l'avance ce qui se passera.

>>> x = compte_triangle(5)
???
>>> y = compte_triangle(6)
???
>>> x
???
>>> y
???
>>> compte_triangle(3) + compte_triangle(4)
???

Écrivez une fonction compte_triangle_bis qui donne le même résultat que compte_triangle, mais en faisant le calcul en sens inverse. Autrement dit, compte_triangle_bis(5) compte le nombre de caractères «*» dans le triangle

*****
****
***
**
*

Pour ceci, il suffit de faire une boucle où l'indice de boucle diminue :

    for i in range(..., ..., -1):
        ...

Si votre fonction ne donne pas le bon résultat, cherchez l'erreur en ajoutant une ligne print pour afficher les valeurs de la variable de boucle et de l'accumulateur (c'est à dire, la variable locale qui accumule le résultat des calculs temporaires).

Programmez, une fonction somme7 à un argument entier n qui calcule la somme des n premiers multiples de 7. Vous devez écrire cette fonction de deux manières différentes :

• une fois avec un for i in range(7, 7*n+1, 7),
• une fois avec un for i in range(1, n+1, 1).

Les deux versions doivent bien entendu donner le même résultat !

Par exemple :

>>> somme7_version1(4)
70
>>> somme7_version2(5)
105

car 7 + 14 + 21 + 28 = 70 et 7 + 14 + 21 + 28 + 35 = 105.

Écrivez une fonction compte_espaces avec un argument s de type chaîne de caractères qui renvoie le nombre de caractères « espace » contenus dans la chaîne s. Par exemple :

>>> compte_espaces("Salut, je m'appelle Bob !")
4

Ajouter une ligne pour afficher le nombre d'espaces à chaque fois que la fonction en trouve un :

>>> compte_espaces("Salut, je m'appelle Bob !")
le caractère 6 est un espace : il y en a 1
le caractère 9 est un espace : il y en a 2
le caractère 19 est un espace : il y en a 3
le caractère 23 est un espace : il y en a 4
4

Lorsque cela fonctionne, commentez la ligne correspondante pour supprimer l'affichage des informations.

Écrivez une fonction nb_differences avec deux paramètres s1 et s2 de type chaînes de caractères qui compte le nombre de lettres différentes entre s1 et s2. Par exemple, pour les chaînes "oiseau" et "bateau", il y a 3 lettres différentes, indiquées par les «*» ci dessous :

          o i s e a u
          b a t e a u
          * * *

          p r u n e
          p o m m e
            * * *

Remarque : lorsque que l'une des chaînes est plus longue que l'autre, on compte une erreur par lettre manquante. Ainsi, il y a 3 lettres de différence entre "poisson" et "poison" :

          p o i s s o n
          p o i s o n
                  * * *

Écrivez un fonction compte_car_doubles à un argument s de type chaîne de caractères qui compte le nombre de symboles doublés dans s. Par exemple,

>>> compte_car_doubles("ce mouton carnassier a une grosse tete")
???

car il y a deux lettres doublées : ce mouton carnassier a une grosse tete.

Essayez de deviner le résultat de votre fonction sur la chaîne "Chut... Le bébé rhinocéros fait la sieste." et vérifiez le résultat.

Écrivez une fonction fact (pour factorielle) avec un argument entier n pour calculer 1 * 2 * 3 * ... * n.

Ajoutez une ligne pour afficher des informations à chaque étape de la boucle :

>>> fact(5)
le compteur de boucle vaut 2 et l'accumulateur vaut 2
le compteur de boucle vaut 3 et l'accumulateur vaut 6
le compteur de boucle vaut 4 et l'accumulateur vaut 24
le compteur de boucle vaut 5 et l'accumulateur vaut 120
120

Mathématiquement, le nombre e est égal à la somme infinie 1 + 1/1! + 1/2! + 1/3! + 1/4! + ...

On peut donc calculer une approximation du nombre e en calculant 1 + 1/1! + 1/2! + 1/3! + 1/4! + ... + 1/n!.

1. Écrivez une fonction approx_e avec un argument entier n pour calculer une telle approximation.
2. Que pensez vous du calcul approx_e(100) lorsque votre fonction fact affiche des informations ? Commentez la ligne correspondante dans la fonction fact avant de continuer.
3. Ajoutez une ligne avec un print (dans la fonction approx_e) pour afficher les approximations successives, et commentez cette ligne dès que vous avez répondu à la question suivante.
4. Le nombre e est à peu près égal à 2.71828 18284 59045 23536 02874 71352 66249.... Cherchez la plus petite valeur de n pour que votre fonction trouve correctement les 10 premières décimales de e.

Mathématiquement, le nombre π/4 est égal à la somme infinie 1/1 + -1/3 + 1/5 + -1/7 + 1/9 + ...

On peut donc calculer une approximation du nombre π en calculant 4*(1/1 + -1/3 + 1/5 + -1/7 + ... + (-1)ⁿ/(2n+1)).

1. Écrivez une fonction approx_pi avec un argument entier n pour calculer une telle approximation.
2. Ajoutez une ligne avec un print pour afficher les approximations successives, et commentez cette ligne dès que vous avez répondu à la question suivante.
3. Le nombre π est à peu près égal à 3.14159 26535 89793 23846 26433 83279 50288.... Cherchez la plus petite valeur de n pour que votre fonction trouve correctement les 5 premières décimales de π.

Reprenez toutes les fonctions du TD3 et programmez les dans votre fichier.