Feuille 1 : Les boucles for et while

Exercice 1 : Somme des entiers de 1 à n

On souhaite disposer d’une fonction qui prend un nombre entier en paramètre et renvoie la somme des nombres de 1 à ce nombre.

1) Écrire le code de la fonction (avec docstring) en utilisant une boucle while.

2) Écrire le code de la fonction (avec docstring) en utilisant une boucle for et range.

Afficher la correction

1)

def somme(n):
    """
    Calcule la somme des nombres de 1 à n.
    Paramètres :
        n (int) : entier jusqu'auquel on souhaite faire la somme.
    Return :
        (int)
    """
    s = 0
    i = 1
    while i <= n:
        s = s + i
        i = i + 1
    return s

# Programme principal pour tester la fonction
print(somme(2) == 3)
print(somme(3) == 6)

2)

def somme(n):
    """
    Calcule la somme des nombres de 1 à n.
    Paramètres :
        n (int) : entier jusqu'auquel on souhaite faire la somme.
    Return :
        (int)
    """
    s = 0
    for i in range(1,n+1):
        s = s + i
    return s

# Programme principal pour tester la fonction
print(somme(2) == 3)
print(somme(3) == 6)

Exercice 2 : Jeu du plus-moins

Écrire un programme qui :

Afficher la correction 
from random import randint
# Affichage de la règle du jeu
print("Vous devez deviner un nombre entre 1 et 99.")
print('-----')
# Choix de la valeur par l'ordinateur
val_ordi = randint(1,99)
# Boucle qui permet au joueur de faire ses propositions
val_joueur = 0 # valeur par défaut (qui est fausse, la boucle se fait donc au moins 1 fois)
nb_coup = 0 # variable qui permet de compter le nombre de tentatives du joueur
while val_joueur != val_ordi:
    val_joueur = int(input("Votre proposition de nombre entre 1 et 99 : "))
    if val_joueur > val_ordi:
        print("Votre proposition est trop grande !")
    elif val_joueur < val_ordi:
        print("Votre proposition est trop petite !")
    print('-----')
    nb_coup = nb_coup + 1
# Affichage de la fin du jeu
print("Bravo, vous avez trouvé, en " + str(nb_coup) + " coups !")

Exercice 3 : Fonction mystère

On considère la fonction suivante : 
def mystere(nombre: int) -> int:
    while nombre >= 5:
        nombre = nombre - 5
    return nombre

1) Quelle valeur va renvoyer mystere(12) ?

2) A quel opération en python cette fonction est-elle équivalente ?

Afficher la correction

1)

mystere(12) renvoie la valeur 2

2)

Cette fonction est équivalente à l'opération % 5

Exercice 4 : De 0,5 en 0,5

En utilisant une boucle while, écrie la fonction aff_demi(n) qui prend un nombre entier en paramètre et affiche les nombres de 0 à n par pas de 0,5.

Exemple :

>>> aff_demi(3)
0 0.5 1 1.5 2 2.5 3
Afficher la correction 
def aff_demi(n):
    val = 0
    while val <= n:
        print(val)
        val = val + 0.5

aff_demi(3)

Exercice 5 (*) : Les tables de multiplications

1) Écrire une fonction qui prend un nombre entier entre 2 et 10 en paramètre et affiche la table de multiplication de ce nombre

Ainsi, avec un paramaètre de valeur 2, la fonction va afficher : 

2 × 1 = 2
2 × 2 = 4
...
2 × 9 = 18
2 × 10 = 20

2) Écrire une fonction qui affiche l'ensemble des tables de multiplication de 2 à 10. On pourra utiliser la fonction du 1).

Afficher la correction 
def affiche_table(nb:int):
    print("=== Table de " + str(nb) + " ===")
    for n in range(11):
        print(str(n) + ' × ' + str(nb) + ' = ' + str(n * nb))

def affiche_toutes_tables():
    for num in range(2, 11):
        affiche_table(num)

#affiche_table(6)
affiche_toutes_tables()

Exercice 6 (*) : Petit robot

On dispose d’un robot que l’on peut faire se déplacer d’une case dans les différentes directions avec les fonctions gauche(), droite(), haut(), bas().

Le robot est initialement situé sur la case en bas à gauche [R].

1) Écrire le code qui permet au robot de se déplacer jusqu’à la case grise pour le parcours n° 1. On utilisera le moins de fois possible les fonctions gauche(), droite(), haut(), bas() au bénéfice des boucles.

Parcours n° 1
Parcours n° 2

2) Même question pour le parcours n° 2.

Afficher la correction 
def deplacement1():
    for _ in range(5):
        for _ in range(3):
            droite()
        haut()

def deplacement2():
    for i in range(1, 6):
        for _ in range(i):
            droite()
        haut()

Exercice 7 (**) : Château de cartes

Robert décide de construire des châteaux de cartes sur le modèle du schéma ci-contre.

PARTIE A

1) Combien de cartes lui faut-il pour construire un château de 1 étage ? de 2 étages ? de 5 étages ?

2) Robert s’aperçoit que le nombre de cartes d’un étage est égale au nombre de cartes de l’étage du dessus auquel on ajoute 3.

2.a) Proposer une méthode pour comptabiliser le nombre de cartes nécessaire pour construire un château de n étages.

2.b) Écrire une fonction (avec docstring) qui prend un nombre entier positif n en paramètre et renvoie le nombre de cartes nécessaire à la construction d’un château de n étages.

PARTIE B

Dans cette partie, on pourra utiliser la fonction de la partie A.

Robert souhaite connaitre, à partir d’un nombre de cartes donné, le plus grand nombre d’étages du château qu’il va pouvoir construire.

1) Un château de combien d’étages peut-il construire avec 10 cartes ? Avec 30 cartes ?

2) Écrire une fonction (avec docstring) qui prend un nombre nb_carte en paramètre et renvoie le plus grand nombre d’étages envisageable pour le château avec ces cartes.

Afficher la correction

Partie A

1)

Pour 1 étage, il faut 2 cartes.

Pour 2 étages, il faut 7 cartes.

Pour 5 étages, il faut 40 cartes.

2)

Le nombre total de cartes nécessaire est la somme du nombre de cartes requis pour chaque étage.

Le nombre de cartes requis pour un étage s'obtient en ajoutant 3 au nombre de cartes de l'étage du dessus, l'étage le plus haut ayant 2 cartes.

3)

def nb_cartes_necessaire(nb_etages:int) -> int:
    """
    Calcule le nombre de cartes nécessaire pour un chateau de nb_etages.
    Paramètres :
        nb_etages (int) : nombre d'étages du chateau
    Return:
        (int) : nombre de cartes nécessaires pour le chateau
    """
    num_etage = 1
    nb_carte_etage = 2
    nb_carte_tot = 2
    while num_etage < nb_etages:
        nb_carte_etage = nb_carte_etage + 3
        nb_carte_tot = nb_carte_tot + nb_carte_etage
        num_etage = num_etage + 1
    return nb_carte_tot

# Programme pour tester la fonction
for i in range(1,6):
    print("Nombre d'étage : " + str(i) + " => Nombre de cartes : " + str(nb_cartes_necessaire(i)) + ".")

Partie B

1)

Avec 10 cartes, il est possible de construire un chateau de 2 étages (7 cartes seront utilisées).

Avec 30 cartes, il est possible de construire un chateau de 4 étages (26 cartes seront utilisées).

2)

La fonction ci-dessous utilise la fonction précédente.

def nb_etages_possible(nb_cartes:int) -> int:
    """
    Calcule le nombre d'étage possible avec un nombre de cartes donné.
    Paramètres:
        nb_cartes (int) : nombre de cartes disponibles
    Return
        (int) : nombre d'étages possibles
    """
    nb_etages = 1
    while nb_cartes_necessaire(nb_etages + 1) < nb_cartes:
        nb_etages = nb_etages + 1
    return nb_etages

# Programme principal pour tester la fonction
print(nb_etages_possible(10))
print(nb_etages_possible(30))