COURS/TP 2 : structures conditionnnelles boucles while et for

Introduction

Dans un certain nombre de problèmes et d'algorithmes, le résultat dépend d'une condition initiale. Par exemple, lors d'une saisie de code de carte bancaire, un programme vérifie que celui-ci est bien valide. Dans le cas où il est correct, le paiement est possible. Dans le cas contraire, le paiement est refusé.

Parfois, on répète une procédure tant qu'une certaine condition est vérifiée. C'est ce que l'on peut constater lorsqu'un utilisateur remplit un formulaire en ligne : tant que les champs obligatoires ne sont pas complétés le site précise à l'utilisateur qu'il manque des informations.

Dans d'autres cas, on veut appliquer une procédure à un ensemble donné. Lorsque l'on veut envoyer une invitation à un groupe particulier, pour chacune des personnes concernées on écrit un message adapté.

1. Structures conditionnelles

1.1 Exemples

Considérons le programme suivant :

In [ ]:
print("saisir votre code")
code = int(input())
lucky = 7777 # le code de votre carte
if code == lucky :
    print("Jackpot !")
else :
    print("code erroné")
    

L'affichage est alors différent suivant la valeur saisie par l'utilisateur. En effet, l'interpréteur affiche "Jackpot !" si code coïncide avec lucky et "code erroné" sinon.

Il est également possible d'écrire un programme où le nombre de disjonctions de cas est plus important :

In [ ]:
print("Quel âge avez-vous ?")
age = int(input())
if age > 65 : 
    print("Vous êtes un senior")
elif age >= 18 :
    print("Vous être majeur")
else : 
    print("vous êtes mineur")

Considérons le programme similaire suivant :

In [ ]:
print("Quel âge avez-vous ?")
age = int(input())
if age > 65 : 
    print("Vous êtes un senior")
if age >= 18 :
    print("Vous être majeur")
else : 
    print("vous êtes mineur")

L'affichage obtenu diffère : dans le premier cas, le mot-clé elif apparaît. Autrement dit, la vérification effectuée est age est inférieur ou égal à 65 et supérieur ou égal à 18. Dans le deuxième cas, le mot-clé est le mot if. Donc la seule condition testée est la comparaison de age avec la valeur 18.

1.2 Structure simple

De manière générale, une structure conditionnelle simple s'écrit ainsi :

In [ ]:
""" 
if condition : 
    instruction1
else :
    instruction2
"""

1.3 Conditions s'excluant mutuellement

Pour des conditions s'excluant mutuellement :

In [ ]:
"""
if condition 1 :
    instruction 1
elif condition 2 : 
    instruction 2
...
elif condition n :
    instruction n
else :
    instruction n+1
"""

2. Structures itératives

2.1 Exemples

Considérons le programme suivant :

In [ ]:
print("saisir un entier")
N = int(input())
jackpot = 777
while N != jackpot :
    print("Vous avez perdu, rejouez !")
    N = int(input())
print("Jackpot !")

On remarque que les instructions à l'intérieur de la boucle while sont éxécutées tant que la valeur N est différente de jackpot. Dès que la proposition N != jackpot est fausse, on quitte la boucle while et on passe aux instructions suivantes.

Grâce à la boucle while, il est possible de réaliser des calculs complexes :

In [ ]:
S = 0
i = 0
while i < 100 :
    i = i+1
    S = S+i*i
print(S)

Il est possible de simplifier le programme précédent comme suit :

In [ ]:
S = 0
for i in range(0,101,1) :
    S = S+i*i
print(S)

2.2 boucle while

De manière générale, la syntaxe est la suivante :

In [ ]:
"""
while condition :
    instructions
"""

condition correspond à la proposition à vérifier pour rester dans la boucle et instructions à la procédure à éxécuter à l'intérieur de la boucle.

2.3 boucle for

Concernant la boucle for :

In [ ]:
"""
for i in range(debut,fin,raison) :
    instruction
"""

debut est le premier entier généré par range, fin le premier qui ne l'est pas et raison est l'écart entre deux entiers consécutifs générés.

In [ ]:
# Exemples :
print("Exemple 1 :")
for i in range(2,7,2) :
    print(i)
print("Exemple 2 :")
for i in range(15,6,-3) :
    print(i)

Dans le cas où raison est égal à $1$, il est possible de l'omettre :

In [ ]:
# Dans les deux cas, on obtient le même résultat :

print("avec la raison :")
for i in range(1,5,1) :
    print(i)

print("sans la raison :")
for i in range(1,5) :
    print(i)

Si debut est égal à $0$ et que raison est égal à $1$, il est possible d'ommettre ces deux nombres :

In [ ]:
# Dans les trois cas, le traitement est identique :
S = 0
for i in range(0,10,1) :
    S = S+i
print("avec debut et raison : ",S)
S = 0
for i in range(0,10) :
    S = S+i
print("avec debut et sans raison : ",S)
S = 0
for i in range(10) :
    S = S+i
print("sans debut et raison : ",S)

3. Travaux pratiques

3.1 Exercices à faire

Exercice 1.

Écrire un programme qui demande à l'utilisateur de saisir deux nombres et qui affiche le plus grand des deux. On pourra compléter le code suivant :

In [ ]:
print("Saisir deux entiers :")
n = int(input())
m = int(input())
"""
Partie à compléter
"""
In [ ]:
#correction exercice 1
print("Saisir deux entiers :")
n = int(input())
m = int(input())
if n>m :
    print(n)
else :
    print(m)

Exercice 2.

Écrire un programme qui demande à l'utilisateur un réel et qui affiche la valeur absolue de ce nombre. On pourra compléter le code suivant :

In [ ]:
print("Saisir un réel")
x = float(input())
"""
Partie à compléter
"""
In [ ]:
# correction exercice 2
print("Saisir un réel")
x = float(input())
if x>=0 :
    print(x)
else :
    print(-x)

Exercice 3.

Écrire un programme qui demande à l'utilisateur de saisir $3$ réels $a,b,c$ et qui affiche les entiers saisis sont dans l'ordre croissant si $a\leq b\leq c$, qui affiche les entiers saisis sont dans l'ordre strictement décroissant si $a> b > c$ et qui affiche ni croissant ni strictement décroissant sinon.

In [ ]:
#correction exercice 3
print("saisir 3 entiers")
a = int(input())
b = int(input())
c = int(input())
if a <= b <= c :
    print("les entiers saisis sont dans l'ordre croissant")
elif a>b>c :
    print("les entiers sont dans l'ordre strictement décroissant")

Exercice 4.

Écrire un programme qui demande à l'utilisateur de saisir $3$ réels $a,b,c$ et qui affiche $|a-b+c|$ si $a<b$ et $|a^2+b^2-c^2|$ sinon.

In [ ]:
#exercice 4 correction
a = float(input("saisir 3 réels\n"))
b = float(input())
c = float(input())
if a<b :
    m = a-b+c
else :
    m = a**2 +b**2 -c**2
if m>=0 :
    print(m)
else :
    print(-m)

Exercice 5.

  1. Écrire un programme qui choisit un entier aléatoire compris entre $0$ et $1000$, qui demande à l'utilisateur de saisir un nombre tant qu'il n'a pas choisi le bon nombre. Par exemple, si le programme choisit aléatoirement le nombre $45$, et que l'utilisateur choisit respectivement les nombres $19$, $90$, $45$, on obtient un affichage du type :

Saisir un nombre :

  1. C'est plus !

Saisir un nombre : 90. C'est moins !

Saisir un nombre : 45. Vous avez trouvé le bon nombre.

On pourra compléter le programme suivant :

In [ ]:
import random # importation d'une bibliotheque permettant de générer un nombre de manière aléatoire
N = random.randint(0,1000)      # N est un entier aléatoire compris entre 0 et 1000
print("choisir un nombre compris entre 0 et 1000")
choix = int(input())
while N != choix :
    """
    a compléter
    """
  1. Modifier votre programme pour qu'il affiche le nombre de tentatives de l'utilisateur. Dans l'exemple précédent, le programme affichera également :
vous avez trouvé le bon nombre en $3$ tentatives.
In [ ]:
# correction exercice 5
import random # importation d'une bibliotheque permettant de générer un nombre de manière aléatoire
N = random.randint(0,1000)      # N est un entier aléatoire compris entre 0 et 1000
print("choisir un nombre compris entre 0 et 1000")
choix = int(input())
tentatives = 1
while N != choix :
    if N>choix :
        print("c'est plus !")
    else :
        print("c'est moins !")
    tentatives = tentatives + 1
    choix = int(input())
print("c'est gagné ! Il vous a fallu",tentatives,"tentatives")
    

Exercice 6.

Écrire un programme de deux façons différentes (l'une à l'aide d'une boucle while et l'autre à l'aide d'une boucle for) affichant tous les entiers pairs compris entre $6$ et $56$ (inclus).

In [ ]:
# correction exercice 6 avec while
entier = 6
while entier <= 56 :
    print(entier)
    entier = entier + 2

# correction avec for
for i in range(6,57,2) :
    print(i)

Exercice 7.

Écrire un programme de deux façons différentes qui demande à l'utilisateur deux entiers positifs $n$ et $p$ et qui affiche le résultat de la somme $1+2^p+\cdots+n^p$.

In [ ]:
#correction exercice 7
S = 0
n = int(input("saisir un entier n"))
p int(input("saisir un entier p"))
k = 1
while k <= n :
    S = S + k**p
    k = k + 1
print(S)

Sbis = 0
n1 = int(input("saisir un entier n1"))
p1 int(input("saisir un entier p1"))
for k in range(n1+1) :
    Sbis = Sbis + k**p1
print(Sbis)

Exercice 8.

On définit la suite de Fibonacci $(F_n)_{n\in \mathbb{N}}$ par : $ F_0 =1, F_1=1, \forall n \in \mathbb{N}, F_{n+2}=F_{n+1}+F_n$.

Écrire un programme qui demande à l'utilisateur de saisir un entier naturel $n$ et qui affiche la valeur $F_n$.

In [ ]:
# correction exercice 8
n = int(input("saisir un entier naturel"))
F0 = 1
F1 = 1
for _ in range(n) :
    F2 = F0 + F1
    F0 = F1
    F1 = F2
print(F0)

Exercice 9.

Écrire un programme qui demande à l'utilisateur de saisir deux chaînes de caractères $a_0a_1\ldots a_{n-1}$ et $b_0b_1\ldots b_{n-1}$ de même longueur et qui affiche le nombre d'éléments de l'ensemble $\left\{ i \in \left\{ 0,1,\ldots,n-1 \right\} | a_i \neq b_i \right\}$. On rappelle que len permet d'obtenir la longueur d'une chaîne.

In [ ]:
# correction exercice 9
a = input("saisir une chaine de caracteres")
b = input("saisir une autre chaine de la même longueur que la précédente")
n = len(a)
if len(b) != n :
    print("suivre les consignes")
else :
    differences = 0
    for i in range(n) :
        if a[i] != b[i] :
            differences = differences + 1
    print(differences)

3.2 Pour les plus rapides

Exercice 10.

On appelle expression bien parenthésé une expression qui contient autant de parenthèses ouvrantes que fermantes et telle que tout préfixe de l'expression contient plus de parenthèses ouvrantes que fermantes. Par exemple, voici $5$ expressions bien parenthésées avec $3$ paires de parenthèses : $()()(), (()()),((())),(())(),()(())$. Par contre, $())($ et $(()))$ ne sont pas bien parenthésées.

Écrire un programme qui demande à l'utilisateur de saisir une chaîne de caractères composée uniquement de parenthèses ouvrantes et fermantes et qui affiche bien parenthésé si l'expression l'est, et mal parenthésé sinon.

Indication : la fonction len permet d'obtenir la longueur d'une chaîne. On considérera dans un premier temps une expression contenant qu'un seul type de parenthèse $()$. On pourra généraliser au cas où il y a également des crochets et des accolades.

In [ ]:
# correction version 1
chaine = input("saisir une expression parenthésée")
ouvrant = 0
fermant = 0
parenthese = True
n = len(chaine)
for i in range(n) :
    if chaine[i] == "(" :
        ouvrant = ouvrant + 1
    if chaine[i] == ")" :
        fermant = fermant + 1
    if ouvrant < fermant :
        parenthese = False
if parenthese and (ouvrant == fermant) :
    print("bien parenthésées")
else :
    print("mal parenthésées")

chaine = input("saisir une expression parenthésée, crochetée, accolée")
compteur_p = 0
compteur_c = 0
compteur_a = 0
parenthesee = True
n = len(chaine)
for i in range(n) :
    carac = chaine[i]
    if carac == "(" :
        compteur_p += 1
    elif carac == ")" :
        compteur_p -= 1
    elif carac == "[" :
        compteur_c += 1
    elif carac == "]" :
        compteur_c -= 1
    elif carac == "{" :
        compteur_a += 1
    elif carac == "}" :
        compteur_a -= 1
    if compteur_p < 0 or compteur_c < 0 or compteur_a < 0 :
        parenthesee = False
if compteur_p == 0 and compteur_c == 0 and compteur_a == 0 and parenthesee :
    print("bien parenthesee")
else :
    print("mal parenthesee")
        
In [ ]: