Accueil » Leçon 4 - Les boucles

Leçon 4 - Les boucles

Objectifs de la leçon :

L'objectif de la leçon est de maîtriser la notion de boucle.

Les boucles sont utiles lorsqu'on veut répéter plusieurs fois une même suite d'instructions.

En Python, on trouve deux types de boucle :

  • La boucle for dans laquelle une variable parcourt une collection de valeurs.
  • La boucle while qui se répète tant qu'une condition est vraie.

Pré-requis :

La leçon 1 : afficher, saisir, les variables, les calculs.

La leçon 2 : les structures conditionnelles.

La leçon 3 : les fonctions. Recommandée mais pas indispensable.

 


Des exemples pour démarrer

Affichage de la table de 8 avec une boucle for :

On veut afficher :

1 x 8 = 8
2 x 8 = 16
3 x 8 = 24
4 x 8 = 32
5 x 8 = 40
6 x 8 = 48
7 x 8 = 56
8 x 8 = 64
9 x 8 = 72
10 X 8 = 80

On peut s'en sortir naïvement en écrivant 10 lignes de code :

Exemple : Affichage naïf de la table de 8


Mais on peut faire mieux avec une boucle !

On observe qu'il y a un compteur qui varie de 1 à 10. Dix fois de suite on doit :

  • Afficher ce compteur
  • Afficher à la suite le signe " x " le 8 et le signe " = "
  • Afficher après le " = " le résultat de compteur * 8
  • Terminer par un saut de ligne.

Voici ce programme écrit avec une boucle for :

Exemple : Affichage de la table de 8 avec une boucle for

Cette boucle for se compose de deux lignes :

  • L'en-tête de boucle :
    for i in range(1,11) :
    Il signifie littéralement : pour chaque i de l'objet range (1,11). Cet objet range (1,11) représente la collection de tous les entiers compris entre 1 et 10.
  • Le corps de la boucle :
    print (i,"x 8 =",i*8)
    Il ne contient ici qu'une seule instruction d'affichage.

Notez bien ceci :
  • L'en-tête de la boucle for se présente sous la forme :
    for compteur in sequence :
    Cette séquence peut-être un objet range, ou une liste, ou une chaîne de caractères, ou plus généralement tout objet itérable.
  • Le corps de la boucle :
    Il est indenté par rapport à l'en-tête.
  • Quand le corps de la boucle a été effectué pour tous les i de l'objet range, la boucle est terminée et le programme continue avec les instructions qui suivent la boucle for, c'est à dire celles qui ne sont plus indentées par rapport à l'en-tête.

Vous pouvez visualiser le déroulement de la boucle en utilisant ce débugueur pas à pas :



Affichage de tous les nombres pairs inférieurs à une limite donnée avec une boucle while :

On va afficher tous les entiers pairs compris entre 0 et 25. Pour cela on va créer un compteur qu'on initialise à 0 et tant que ce compteur est inférieur ou égal à 25, on l'affiche et on l'augmente de 2.

Exemple : Affichage des entiers pairs inférieurs à 25

Cette boucle while se compose de trois lignes :

  • L'en-tête de boucle :
    while i <= 25 :
    Le corps de la boucle sera effectué tant que i sera inférieur ou égal à 25.
  • Le corps de la boucle :
     print (i)
     i = i + 2
    Il contient l'instruction d'affichage et l'incrémentation du compteur.

Notez bien ceci :
  • L'en-tête de la boucle while se présente sous la forme :
    while condition :
    La boucle est effectuée tant que la condition est vraie.
  • Le corps de la boucle :
    Il est indenté par rapport à l'en-tête.
  • Quand la condition est fausse, la boucle n'est plus effectuée et le programme continue avec les instructions qui suivent la boucle while, c'est à dire celles qui ne sont plus indentées par rapport à l'en-tête. Dans ce cas précis, on sort de la boucle quand i vaut 26.

Vous pouvez visualiser le déroulement de la boucle en utilisant ce débugueur pas à pas :

Ressources utiles

L'ESSENTIEL AVEC DES EXEMPLES DE BASE

Les boucles sont utiles lorsqu'on veut répéter plusieurs fois une même suite d'instructions.


Syntaxe de la boucle for :

for i in sequence :
   instruction1
   instruction2
   instruction3
   ...

suite du programme à exécuter en sortie de boucle
  • sequence peut être un objet range, une liste, une chaîne de caractères ou plus généralement n'importe quel objet itérable.
  • L'en tête de boucle termine par :
  • La suite des instructions à répéter est indentée par rapport à l'en-tête.

Quelques exemples :

Exemple : Affichage de la table de 8

Affichage de la table de 8 avec une boucle for

Exemple : Affichage des voyelles d'une chaine de caractères

On affiche une par une toutes les voyelles de la chaîne de caractères "Python c'est fun ! Yes !!!". Pour cela on crée une variable car qui parcourt les caractères de la chaîne un par un.

Exemple : Somme des entiers d'une liste

La boucle for ci-dessous calcule la somme des 8 premiers termes de la suite de Fibonacci.



Syntaxe de la boucle while :

while condition :
   instruction1
   instruction2
   instruction3
   ...

suite du programme à exécuter en sortie de boucle
  • Tant que la condition est vraie, la boucle est effectuée.
  • L'en tête de boucle termine par :
  • La suite des instructions à répéter est indentée par rapport à l'en-tête.

Quelques exemples :

Exemple : Affichage de la table de 8

Affichage de la table de 8 avec une boucle while

Exemple : Affichage de tous les diviseurs d'un entier

La boucle while ci-dessous passe en revue tous les entiers compris entre 1 et n=24. Chaque fois qu'elle rencontre un diviseur de n, elle l'affiche.
Pour savoir si i est un diviseur de n, on teste si le reste de la division de n par i est nul.

Exemple : Temps de doublement d'un capital C placé à t % par an

La boucle while ci-dessous augmente le capital de départ de t% chaque année, tant que le capital n'a pas été doublé.
En sortie de boucle, on affiche le nombre d'années qu'il a fallu pour doubler le capital et le temps que cela a duré.

Quelques exemples plus poussés

Calcul de la factorielle d'un nombre entier

On rappelle que le nombre "factorielle de n", noté n! est le produit des entiers naturels compris entre 1 et n :
1! = 1
2! = 2 x 1 = 2
3! = 3 x 2 x 1 = 6
4! = 4 x 3 x 2 x 1 = 24
....
n! = n x (n-1) x (n-2) x .... x 2 x 1
On remarque que cette définition s'écrit aussi n! = n x (n-1) ! pour n>=2.
Pour que cette règle soit encore valable lorsque n = 1, on convient que 0! =1 (et pas 0)

Exemple : Calcul de la factorielle d'un nombre

Le code ci-dessous permet de calculer 8 !.
On initialise une variable fact à 1. Puis on la multiplie successivement par 2, 3, 4., .., 8 à l'aide d'une boucle for.
En sortie de boucle, fact vaut 8 !.



Afficher un motif

On veut afficher le "carré" suivant :

*****
*****
*****
*****
*****
Il y a autant de lignes que de caractères sur chaque ligne (ici, 5). On a le choix du nombre de lignes et du caractère affiché.

 

Exemple : Affichage d'un carré de N lignes contenant chacune N fois le caractère C

Le code ci-dessous affiche un motif de 7 lignes contenant chacune 7 fois le caractère @.
La boucle for tourne 7 fois (range (1,N+1)).
A chaque passage dans la boucle, on affiche une ligne de sept @ : (print (C*N))



La croissance du nénuphar

Un nénuphar recouvre 1 m² d'un étang de 30 m². Sachant qu'il double de surface tous les jours, dans combien de jours aura-t-il recouvert tout l'étang ?

Exemple : Croissance du nénuphar

A chaque passage dans la boucle while, le code ci-dessous double la surface du nénuphar et augmente le nombre de jours de 1.
On réitère le procédé tant que la surface en cours (S) est inférieure à la surface de l'étang (30).
Quand on sort de la boucle, c'est que S>=30, donc que l'étang est recouvert.



Conversion Dollars -> Euros

Afficher une table de conversion de montants en Dollars en montants en Euros.

Les montants en Dollars varieront de 50 $ en 50 $

On affichera une nouvelle ligne tant que le montant en Euros ne dépasse pas 1000 €

Exemple : Table de conversion $ -> €



Des tables de multiplication à répétition (boucles imbriquées)

On tire des nombres entiers au hasard entre 0 et 10.

Si le nombre est compris entre 1 et 10, on affiche sa table, sinon, on s'arrête en disant au revoir.

Exemple : Tables à répétition...

On sait que la boucle suivante affiche la table de t :
for i in range(1,11) :
  print (i,\"x\",t,\"=\",i*t)
Puisqu'il faut afficher plusieurs tables, on va imbriquer cette boucle dans une boucle globale.
Dans cette boucle while globale, on tire au hasard la variable t (celle dont on veut la table) puis on affiche sa table si t n'est pas nul. Si t est nul, la boucle s'arrête.
Remarque : puisque la condition d'exécution d'une boucle while est testée en entrée de boucle, on a préféré initialiser t avant l'entrée dans la boucle. La dernière instruction de la boucle est le tirage d'un nouveau t pour le passage suivant.
Faites tourner plusieurs fois ce programme pour bien voir que le nombre de tables affichées est aléatoire.

Des pièges à éviter

Oubli des : à la fin de l'en-tête d'une boucle for ou while.

ça ne compile pas !

Oubli des indentations après l'en-tête d'une boucle for ou while.

ça ne compile pas !

Continuer à indenter le code en fin de boucle alors qu'on voulait sortir de la boucle

Les instructions indentées font partie de la boucle donc sont répétées...

Exemple : Quand on oublie de désindenter en fin de boucle....


Croire que le deuxième paramètre d'un objet range représente sa dernière valeur.

Non, c'est la valeur de stop. C'est la valeur qui fait sortir de la collection définie par l'objet range.

Exemple : Il manque l'affichage de 10 * 8 ....


Oubli de faire évoluer la variable de contrôle d'une boucle while.

En général, boucle infinie !

Exemple : Il manque l'incrémentation du compteur ....

Quand vous lancerez le code ci-dessous, l'instruction située après la fin de la boucle ne sera pas exécutée puisque i n'évolue pas et vaut donc tout le temps 1. La condition i < 11 est toujours vraie, ce qui fait que la boucle affiche sans fin :
8 x 1 = 8
8 x 1 = 8
8 x 1 = 8
...
8 x 1 = 8
...

Remarque : le système sur lequel vous travaillez est protégé contre ce type de problème donc il arrête de lui même les programmes en boucle en indiquant un crash pour limite de temps dépassée.

Bon à savoir

La clause else en fin de boucle for ou while :

Un else en fin de boucle for ou while donne la suite des instructions à réaliser lorsque la boucle est terminée.

Les deux exemples suivants donnent la valeur du compteur en fin de boucle.

Exemple : Affichage des doubles des entiers compris entre 0 et 7 avec une boucle for

Exemple : Affichage des doubles des entiers compris entre 0 et 7 avec une boucle while



L'instruction break interrompt l'exécution d'une boucle for ou while

Exemple : ce programme tire un maximum de 10 nombres au hasard entre 0 et 10 et les affiche. Si le nombre sorti est 0, la boucle s'arrête.

Exemple : Sortie et affichage de 10 nombres au hasard entre 0 et 10 avec interruption si le nombre sorti est 0.

Conseil : exécuter plusieurs fois le programme pour voir la différence.



L'instruction continue provoque le passage à l'itération suivante d'une boucle for ou while

Exemple : ce programme affiche les nombres impairs compris entre 11 et 30 sauf s'ils sont multiples de 3.

Exemple : Affichage des nombres impairs compris entre 11 et 30 qui ne sont pas multiples de 3.

Dans le code suivant, on parcourt l'objet range (11,31,2) :
  • on part de 11,
  • on va de 2 en 2 donc on parcourt tous les nombres impairs,
  • si le nombre rencontré n'est pas multiple de 3, on l'affiche, sinon on continue,
  • quand on rencontre 31, on sort de la collection donc la boucle s'arrête.

Vous noterez que le programme affiche bien tous les nombres impairs entre 11 et 30 sauf 15, 21 et 27 qui sont multiples de 3.


Autre exemple : ce programme parcourt la liste des prénoms d'une famille et affiche ceux qui ne contiennent pas la lettre e.

Exemple : Les prénoms qui ne contiennent pas la lettre e.

Dans le code ci-dessous, notez bien la condition :
not("e" in prenom)
qui permet de s'assurer que la lettre e n'est pas contenue dans la variable prenom.

Le quizz

Exercice à réponse courte : Fin de boucle
for i in range (8,17,3) :
  print (i)
Quelle est la valeur du compteur i en sortie de boucle ?
Bien !

Exercice à réponse courte : Fin de boucle
i = 8
while i < 17 :
  print (i)
  i += 3
Quelle est la valeur du compteur i en sortie de boucle ?
Bien !

Exercice à choix multiple : Cumul
Qu'affiche le programme suivant ?
s = 0
for i in range(1,6,2) :
  s += i
print (s)
Bien !

Exercice à choix multiple : Diviseur commun
Qu'affiche le programme suivant ?
a = 75
b = 105
d = min(a,b)
while (a%d != 0 or b%d !=0) :
  d -= 1
print (d)
Bien !

Exercice à choix multiple : Affichage avec une boucle while
Qu'affiche le programme suivant ?
i = 10
while i > 0 :
  i -= 4
  print (i)
Bien !

Exercice à choix multiple : Saisie blindée avec une boucle while
Ce code oblige l'utilisateur à saisir un nombre entier dans quel intervalle ?
a = 0
while a < 20 or a > 50 :
  a = int(input())
Bien !

Exercice à choix multiple : Diviseurs
Qu'est ce qu'affiche le code suivant ?
a = 10
i = 3
while i <= a :
  if a%i == 0 :
     print (i)
  i += 1
Bien !

Exercice à choix multiple : Salut !
Laquelle de ces boucles affiche salut 10 fois ?
# boucle 1
for i in range (1,10) :
  print ("salut")

# boucle 2
for i in range (0,10) :
  print ("salut")

# boucle 3
for i in range (0,9) :
  print ("salut")
Bien !

Exercice à réponse courte : Bonjour !
Combien de fois est affiché le mot Bonjour ?
i = 1
while i < 5 :
  print ("Bonjour")
  i += 2
Bien !

Exercice à réponse courte : Syracuse
Qu'est-ce qu'affiche le code suivant ?
s = 50
for i in range(10 , 20) :
  if s%2 == 0 :
     s /= 2
  else :
     s = 3*s + 1
print (s)
Bien !

Exercice mêlé : Une boucle while secouée
Ordonnez les lignes de code suivantes pour que s'affiche 6 7 8 9 10.
  • i += 1
  • i = 5
  • print (i)
  • while i < 10 :
Bien !

Exercice mêlé : Des boucles for mélangées
Ordonnez les lignes suivantes pour que ce code affiche 6.
  • print (s)
  • s = i
  • s = j
  • if i > j :
  • for j in range (5,7) :
  • for i in range (1,3) :
  • else :
Bien !

Exercice à réponse courte : Longueur effective
Qu'est-ce qu'affiche le code suivant ?
L = 0
for i in "Python c'est royal !!!" :
  if i != " " :
     L += 1
print (L)
Bien !

Exercice à réponse courte : Prénoms sans a
Qu'est-ce qu'affiche le code suivant ?
c=0
for prenom in ["Maxime","Loïc","Audrey","Chloé","Anne","Guillaume"] :
  if not("a" in prenom) :
     c += 1
print (c)
Bien !

Exercice à réponse courte : Des voyelles
Qu'est-ce qu'affiche le code suivant ?
v=0
for prenom in ["Maxime","Loïc","Audrey","Chloé","Anne","Guillaume"] :
  for car in prenom :
     if car in "aeiouy" :
        v += 1
print (v)
Bien !

Exercice à choix multiple : Multiples de 15
Que diriez vous du code suivant ?
N = 15
k = 10
while N * k < 1000 :
  k += 1
print ( N * k)
Bien !

Exercice à choix multiple : Multiples de 15 bis
Que diriez vous du code suivant ?
N = 15
k = 10
while N * k < 1000 :
  k += 1
  print ( N * k)
Bien !

Exercice à choix multiple : Minuscules -> Majuscules
Que diriez vous du code suivant ? Indication : la fonction upper transforme une chaîne de caractères en majuscules.
L= ["Maxime","Loïc","Audrey","Chloé","Anne","Guillaume"]
NewL = []
for prenom in L :
  NewPrenom = ""
  for car in prenom :
     if car in "aeiouy" :
        NewPrenom = NewPrenom + car.upper()
     else :
        NewPrenom = NewPrenom + car
  NewL.append(NewPrenom)

for prenom in NewL :
  print (prenom)
Bien !

Exercice à choix multiple : Boucles for imbriquées
Combien ce programme affiche-t-il de nombres ?
s=0
for i in range (1,11) :
  for j in range (2,8) :
     if i>j :
        print (i)
     else :
        print (j)
     s += 1
print (s)
Bien !

Exercice à choix multiple : Boucles for imbriquées bis
Quels sont le premier et le dernier nombre affichés par ce programme ?
for i in range (1,11) :
  for j in range (2,8) :
     if i>j :
        print (i)
     else :
        print (j)
Bien !

Questions souvent posées

Peut-on tester plusieurs conditions dans une boucle while ?

Bien sûr ! Il arrive fréquemment qu'on doive vérifier plusieurs conditions pour que la boucle continue, dans ce cas il faut connecter les conditions à l'aide des connecteurs logiques ET ( and ), OU ( or ) et la négation ( not ).

Exemples :

  • while i <= 10 and trouve == 0 # tant que i est inférieur ou égal à 10 et qu'on n'a pas trouvé ce qu'on cherchait.
  • while not(a%d == 0 and b%d ==0) # tant que d n'est pas un diviseur commun de a et b

Quand est-ce qu'il vaut mieux utiliser un type de boucle plutôt qu'une autre ?

C'est souvent une affaire de goût et de style personnel de programmation. En Python, la boucle for est recommandée lorsque le compteur doit parcourir une liste structurée de valeurs.

Est-ce qu'il y a une différence entre un objet range et un objet list ?

Oui, un objet range est défini en mémoire par sa valeur de départ, sa valeur de stop et son pas alors que pour une liste, c'est l'ensemble de toutes les valeurs qui est stockée en mémoire.

Exemple : Les deux en-têtes de boucle suivants sont équivalents mais le premier prend moins de place en mémoire :

  • for i in range ( 5 , 17 , 2 )
  • for i in [ 5 , 7 , 9 , 11 , 13 , 15 ]

Notez qu'on peut transformer un objet range en list si besoin : list ( range ( 5 , 17 , 2 ) ) donne [ 5 , 7 , 9 , 11 , 13 , 15 ]

Pour plus d'informations sur l'objet range : https://docs.python.org/3/library/stdtypes.html?highlight=range#range


Exemples de questions de cours

  • Quelle est la syntaxe d'une boucle for ?
  • Quelle est la syntaxe d'une boucle while ?
  • Décrire le plus complètement possible un objet range.

Des exercices pour s'entraîner

Exercice de code : Table de multiplication
Ecrire un programme qui attend un entier et qui affiche la table de multiplication de cet entier au format suivant :

8 x 1 = 8
8 x 2 = 16
8 x 3 = 24
8 x 4 = 32
8 x 5 = 40
8 x 6 = 48
8 x 7 = 56
8 x 8 = 64
8 x 9 = 72
8 x 10 = 80

Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : De la table de N à la table de P
Ecrire un programme qui attend deux entiers N et P et qui affiche la table de multiplication de tous les entiers compris entre N et P, N et P inclus (voir ci-dessous pour N=4 et P=7).
Si P<N, le programme n'affiche rien.
Une ligne vierge sépare deux tables affichées.

4 x 1 = 4
4 x 2 = 8
4 x 3 = 12
4 x 4 = 16
4 x 5 = 20
4 x 6 = 24
4 x 7 = 28
4 x 8 = 32
4 x 9 = 36
4 x 10 = 40

5 x 1 = 5
5 x 2 = 10
5 x 3 = 15
5 x 4 = 20
5 x 5 = 25
5 x 6 = 30
5 x 7 = 35
5 x 8 = 40
5 x 9 = 45
5 x 10 = 50

6 x 1 = 6
6 x 2 = 12
6 x 3 = 18
6 x 4 = 24
6 x 5 = 30
6 x 6 = 36
6 x 7 = 42
6 x 8 = 48
6 x 9 = 54
6 x 10 = 60

7 x 1 = 7
7 x 2 = 14
7 x 3 = 21
7 x 4 = 28
7 x 5 = 35
7 x 6 = 42
7 x 7 = 49
7 x 8 = 56
7 x 9 = 63
7 x 10 = 70

Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Tables de multiplication à répétition
Ecrire un programme qui attend un entier puis qui affiche sa table de multiplication. Ensuite, on entre de nouveau un entier puis on affiche sa table et ainsi de suite jusqu'à ce que l'entier entré soit égal à-1.
Quand on rencontre l'entier -1, le programme s'arrête (sans afficher la table de -1).
Une ligne vierge sépare deux tables affichées comme le montre l'exemple ci-dessous pour lequel les entiers successivement entrés on été 16, 17, 3 et -1.

16 x 1 = 16
16 x 2 = 32
16 x 3 = 48
16 x 4 = 64
16 x 5 = 80
16 x 6 = 96
16 x 7 = 112
16 x 8 = 128
16 x 9 = 144
16 x 10 = 160

17 x 1 = 17
17 x 2 = 34
17 x 3 = 51
17 x 4 = 68
17 x 5 = 85
17 x 6 = 102
17 x 7 = 119
17 x 8 = 136
17 x 9 = 153
17 x 10 = 170

3 x 1 = 3
3 x 2 = 6
3 x 3 = 9
3 x 4 = 12
3 x 5 = 15
3 x 6 = 18
3 x 7 = 21
3 x 8 = 24
3 x 9 = 27
3 x 10 = 30

Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : L'alphabet dans tous les sens
Ecrire un programme qui attend un entier entre 1 et 4.

  • Si l'entier vaut 1, le programme affiche l'alphabet en minuscules à l'endroit.
  • Si l'entier vaut 2, le programme affiche l'alphabet en minuscules à l'envers.
  • Si l'entier vaut 3, le programme affiche l'alphabet en majuscules à l'endroit.
  • Si l'entier vaut 4, le programme affiche l'alphabet en majuscules à l'envers.

Voilà les différents formats de sortie :

  • abcdefghijklmnopqrstuvwxyz
  • zyxwvutsrqponmlkjihgfedcba
  • ABCDEFGHIJKLMNOPQRSTUVWXYZ
  • ZYXWVUTSRQPONMLKJIHGFEDCBA

Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Liste des diviseurs d'un entier
Ecrire un programme qui attend un entier puis affiche la liste de ses diviseurs au format suivant :
[1, 2, 3, 4, 6, 8, 12, 24]
Ici, l'entier est 24, bien entendu.
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Liste des multiples d'un entier
Ecrire un programme qui attend dans cet ordre un entier N et une limite L.
Le programme affiche la liste des multiples de N compris entre 0 et L au format suivant : [0, 15, 30, 45]
Dans cet exemple, N = 15 et L = 50.
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : N est-il premier ?
Ecrire un programme qui attend un entier N >= 2 et qui dit si N est premier ou pas
Exemples de message de sortie : 
  • 49 n'est pas premier
  • 101 est premier

Rappel : un nombre entier est premier s'il a exactement 2 diviseurs, 1 et lui même.

Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : PGCD de deux entiers
Ecrire un programme qui attend deux entiers supérieurs ou égaux à 1 et qui affiche leur PGCD selon le modèle suivant :
Le PGCD de 48 et 84 est 12.
Pour le calcul du PGCD, on pourra utiliser un algorithme naïf ou l'algorithme d'Euclide :
http://villemin.gerard.free.fr/ThNbDemo/AlgoEucl.htm
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un carré vide
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le "carré" vide suivant :
*****
*   *
*   *
*   *
*****
Il y a N lignes (ici, N = 5 et le caractère d'affichage est *).
La première et la dernière lignes sont "pleines". Elles contiennent N caractères.
Les lignes intermédiaires sont "creuses" (il y a des espaces entre le premier et le dernier caractère).
Si N=1, on a :
*
Si N=2, on a :
**
**
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle plein_01
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle plein suivant :
*
**
***
****
*****
Il y a N lignes (ici, N = 5 et la caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle plein_02
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle plein suivant :
    *
  **
 ***
****
*****
Il y a N lignes (ici, N = 5 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle plein_03
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle plein suivant :
*****
****
***
**
*
Il y a N lignes (ici, N = 5 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle plein_04
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle plein suivant :
*****
****
 ***
  **
   *
Il y a N lignes (ici, N = 5 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle plein_05
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle plein suivant :
    *
  ***
 *****
*******
*********
Il y a N lignes (ici, N = 5 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle plein_06
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle plein suivant :
*********
*******
 *****
  ***
   *
Il y a N lignes (ici, N = 5 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle vide_01
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle vide suivant :
*
**
* *
*  *
*   *
******
Il y a N lignes (ici, N = 6 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle vide_02
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle vide suivant :
     *
   **
  * *
 *  *
*   *
******
Il y a N lignes (ici, N = 6 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle vide 03
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle vide suivant :
*****
*  *
* *
**
*
Il y a N lignes (ici, N = 5 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle vide 04
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle vide suivant :
*****
*  *
 * *
  **
   *
Il y a N lignes (ici, N = 5 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle vide 05
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle vide suivant :
    *
  * *
 *   *
*     *
*********
Il y a N lignes (ici, N = 5 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un triangle vide 06
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le triangle vide suivant :
*********
*     *
 *   *
  * *
   *
Il y a N lignes (ici, N = 5 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un losange plein
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le losange plein suivant :
    *
  ***
 *****
*******
*********
*******
 *****
  ***
   *
Il y a 2*N -1 lignes (ici, N = 5 et le caractère d'affichage est *).
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Affichage d'un losange vide
Ecrire un programme qui attend dans cet ordre un entier N>=2 et un caractère d'affichage puis qui affiche le losange vide suivant :
    *
  * *
 *   *
*     *
*       *
*     *
 *   *
  * *
   *
Il y a 2*N -1 lignes (ici, N = 5 et le caractère d'affichage est *).
On a le choix du nombre de lignes et du caractère affiché.
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Probabilité d'obtenir un 10 en jouant 2 dés
La probabilité d'obtenir 10 en lançant 2 dés à 6 faces est égale à 3 / 36, soit 0.083333.
La loi faible des grands nombres de Bernouilli dit que la fréquence d'apparition d'un événement se rapproche de la probabilité lorsque le nombre de tirages est grand.
Cet exercice propose de vérifier cette loi dans le cas où on cherche à obtenir un 10 en lançant 2 dés.
Pour cela on va répéter des parties dans lesquelles on lance successivement 2 dés, avec un nombre de lancers de plus en plus grand. D'abord 1 lancer, puis 5, puis 25, puis 125 et ainsi de suite en multipliant le nombre de lancers par 5 à chaque fois sans dépasser 10 000 lancers.
Quand chaque partie est finie, on affiche une ligne indiquant le nombre de lancers, le nombre de coups gagnants, la fréquence de gain et la différence entre la probabilité et la fréquence de gain.

Voilà le format attendu pour la sortie :

1 0 0.0 -0.08333333333333333
5 0 0.0 -0.08333333333333333
25 2 0.08 -0.003333333333333327
125 18 0.144 0.06066666666666666
625 48 0.0768 -0.0065333333333333354
3125 272 0.08704 0.0037066666666666775

 
Remarque importante : comme ce programme génère des nombres aléatoires, il n'y a aucune chance que votre sortie corresponde à celle du système. Donc votre programme sera toujours évalué incorrect.
Pas de panique ! Ce que vous devez constater dans votre sortie, c'est que la fréquence s'approche de 0.08

Si vous voulez tester votre programme plus finement, en augmentant sensiblement le nombre de lancers, faites-le tourner en local sur votre PC personnel et non sur ce site, vous ne serez pas bloqué par des limites de "temps dépassé".

Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Multiplier son capital !!!
Ecrire un programme qui attend dans cet ordre :
  • Un capital initial C0
  • Un taux d'intérêt annuel T. Pour 2%, on attend 0.02.
  • Un coefficient multiplicateur M

Le programme retourne le nombre d'années N nécessaires pour que le capital soit multiplié par M ainsi que le capital obtenu après ces N années.
Modèle de sortie :

Capital initial : 5231
Taux : 5.0 %
Apres 15 ans, votre capital aura été multiplié par 2
Vous disposerez alors de 10874
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : La suite de Fibonacci
La suite de Fibonacci est une suite d'entiers dans laquelle chaque terme est la somme des deux termes qui le précèdent. Ses valeurs dépendent de la donnée de ses deux premiers termes.
Ecrire un programme qui affiche les termes d'une suite de Fibonacci, du N ième au P ième.
Ce programme attend dans cet ordre :
  • Les deux premiers termes
  • La valeur de N
  • La valeur de P


Modèles de sortie :

Si N <= P (Exemple avec 0 et 1 comme premiers termes, N = 4 et P = 7)

[3, 5, 8, 13]
Si N > P :
N = 7 > P = 4
Programme stoppé
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Exercice de code : Du blé sur un jeu d'échec !
On raconte qu'il y a environ 14 siècles, un Prince de Perse voulait récompenser l'inventeur du jeu des échecs. Ce dernier lui demanda le cadeau suivant : 1 grain de blé sur la première case de l'échiquier, 2 sur la deuxième, 4 sur la troisième et ainsi de suite en doublant jusqu'à la 64 ème case.
Sachant qu'un grain de blé pèse en moyenne un quart de gramme, combien de temps aurait-il fallu pour satisfaire le vœu de l'inventeur au rythme actuel de la production mondiale de blé qui est d'environ 650 millions de tonnes par an (en 2013) ?
Vous pouvez entrer des données pour le programme dans la boîte ci-dessous.

Un résumé produit par des étudiants

Résumé du chapitre 4

Il a été réalisé par Paul RENAUDIN, promo 2016-2017

Il est assez minimaliste et mériterait d'être complété mais l'essentiel y est.

c'est à dire une collection d'éléments qui peut être parcourue un à un
Un objet range représente une séquence de nombres régulièrement espacés
Une liste est une structure de données ordonnée qui peut contenir des éléments de types différents : nombres entiers, nombres à virgule, chaînes de caractères et listes
c'est à dire une collection d'éléments qui peut être parcourue un à un
La suite de Fibonacci est une suite d'entiers dans laquelle chaque terme est la somme des deux termes qui le précèdent. Elle commence généralement par les termes 0 et 1
En effet, il y a 6x6=36 sorties possibles et parmi ces 36 sorties, celles qui donnent 10 sont (6,4), (5,5) et (4,6)
Il faudrait pouvoir pousser bien plus loin mais ce site refuse que les programmes s'exécutent en prenant trop de temps.