WarmUp : 1 NSI

A1 : trace d'exécution et pseudo code

Fonction mystère avec if / else

On considère la fonction Python suivante :

def mystere(a, b):
    if a > b:
        res = a - b
    else:
        res = b - a
    return res

1. Réaliser la trace d'exécution de l'appel mystere(8, 3).

2. Réaliser la trace de l'appel mystere(4, 9).

3. À partir des deux traces, expliquer ce que fait cette fonction.

4. Quelle valeur renvoie mystere(12, 12) ?

Correction

Trace de mystere(8, 3) :

Étape | a | b | res | Test / action
-------------------------------------------
1     | 8 | 3 |  -  | Appel de mystere(8, 3)
2     | 8 | 3 |  -  | a > b : True
3     | 8 | 3 |  5  | res = 8 - 3
4     | 8 | 3 |  5  | return res → 5

Trace de mystere(4, 9) :

Étape | a | b | res | Test / action
-------------------------------------------
1     | 4 | 9 |  -  | Appel de mystere(4, 9)
2     | 4 | 9 |  -  | a > b : False
3     | 4 | 9 |  5  | res = 9 - 4
4     | 4 | 9 |  5  | return res → 5

La fonction renvoie la différence positive entre a et b.

mystere(12, 12) renvoie 0.

Fonction mystère avec une boucle for

On considère la fonction Python suivante :

def mystere(n):
    somme = 0
    for i in range(1, n + 1):
        somme = somme + i
    return somme

1. Réaliser la trace d'exécution de mystere(5).

2. Donner la valeur retournée.

3. Expliquer ce que calcule cette fonction pour un entier positif n.

Correction

i | somme avant | somme après
-----------------------------
1 |      0      |      1
2 |      1      |      3
3 |      3      |      6
4 |      6      |     10
5 |     10      |     15

La fonction renvoie 15.

Elle calcule la somme des entiers de 1 à n.

Fonction mystère avec for et if

On considère la fonction Python suivante :

def mystere(n):
    res = 0
    for i in range(1, n + 1):
        if i * i <= n:
            res = i
    return res

1. Réaliser la trace d'exécution de mystere(20).

Dans la trace, faire apparaître les valeurs de i, du test i * i <= n et de res.

2. Quelle valeur est retournée ?

3. À partir de la trace, expliquer ce que représente la valeur retournée.

4. Sans refaire toute la trace, prévoir la valeur de mystere(36).

Correction

i  | i * i <= 20 | res
-----------------------
1  | True        | 1
2  | True        | 2
3  | True        | 3
4  | True        | 4
5  | False       | 4
6  | False       | 4
...
20 | False       | 4

La fonction renvoie 4.

Elle renvoie le plus grand entier dont le carré est inférieur ou égal à n.

mystere(36) renvoie 6.

Fonction mystère avec une boucle while

On considère la fonction Python suivante :

def mystere(n):
    compteur = 0
    while n >= 10:
        n = n - 10
        compteur = compteur + 1
    return compteur

1. Réaliser la trace d'exécution de mystere(37).

2. Quelle valeur est retournée ?

3. Expliquer ce que calcule cette fonction pour un entier positif n.

4. Prévoir la valeur renvoyée par mystere(85).

Correction

Étape | n  | compteur | Test n >= 10
------------------------------------
0     | 37 |    0     | True
1     | 27 |    1     | True
2     | 17 |    2     | True
3     |  7 |    3     | False

La fonction renvoie 3.

Elle calcule le quotient entier de n par 10.

mystere(85) renvoie 8.

Warhammer: The Old World — la charge des chevaliers de Bretonnie

Figurines de chevaliers bretonniens de Warhammer: The Old World
Chevaliers de Bretonnie — Warhammer: The Old World (Warhammer Community).

Une unité de 24 Orques affronte des chevaliers du Royaume de Bretonnie. On utilise un modèle simplifié et fictif de combat, qui ne correspond pas aux règles officielles du jeu.

À chaque tour, les chevaliers éliminent 2 * tour Orques. Au premier tour, leur charge élimine 3 Orques supplémentaires.

On considère la fonction Python suivante :

def charge_bretonnienne():
    orques = 24
    for tour in range(1, 5):
        pertes = 2 * tour
        if tour == 1:
            pertes = pertes + 3
        orques = orques - pertes
    return orques

1. Réaliser la trace d'exécution de l'appel charge_bretonnienne().

2. Quelle valeur la fonction renvoie-t-elle ? Que représente-t-elle dans ce combat ?

Correction

Trace de charge_bretonnienne() :

Ligne orques tour pertes Tests
2 24 - -
3 24 1 - Boucle : oui
4 24 1 2
5 24 1 2 1 == 1 : True
6 24 1 5
7 19 1 5
3 19 2 5 Boucle : oui
4 19 2 4
5 19 2 4 2 == 1 : False
7 15 2 4
3 15 3 4 Boucle : oui
4 15 3 6
5 15 3 6 3 == 1 : False
7 9 3 6
3 9 4 6 Boucle : oui
4 9 4 8
5 9 4 8 4 == 1 : False
7 1 4 8
3 1 4 8 Boucle : terminée
8 1 4 8 return 1

2. La fonction renvoie 1 : il reste un Orque après les quatre tours.

LP1 : langage de programmation 1

Analyse d'erreur de type en Python

Un élève propose le code Python suivant :

annee_naissance = input("Votre année de naissance : ")
age = 2026 - annee_naissance
print("Vous avez", age, "ans.")

Expliquer l'erreur produite lors de l'exécution et proposer une version corrigée en Python.

Correction

input() renvoie une chaîne de caractères (str). On ne peut pas effectuer une soustraction entre un nombre entier et du texte (TypeError).

Code Python corrigé :

annee_naissance = int(input("Votre année de naissance : "))
age = 2026 - annee_naissance
print("Vous avez", age, "ans.")

Créer une fonction de conversion de température en Python

On souhaite convertir une température de Celsius vers Fahrenheit avec la formule : \(F = C \times 1.8 + 32\).

Écrire en Python une fonction celsius_vers_fahrenheit(celsius) qui prend une température en degrés Celsius en paramètre et renvoie la température correspondante en degrés Fahrenheit.

Faire un appel de la fonction avec la valeur 20 et afficher le résultat.

Correction

Code Python :

def celsius_vers_fahrenheit(celsius):
    f = celsius * 1.8 + 32
    return f

print(celsius_vers_fahrenheit(20))

Le programme affiche 68.0.

Créer une fonction avec un paramètre par défaut en Python

Écrire en Python une fonction prix_ttc(prix_ht, taux_tva=20) qui prend en paramètre un prix hors taxe et un taux de TVA, égal à 20 par défaut, puis renvoie le prix TTC.

Faire deux appels de la fonction avec les appels un prix de 50 et une TVA de 10, ainsi qu'in prix de 100.

Correction

Code Python :

def prix_ttc(prix_ht, taux_tva=20):
    res = prix_ht * (1 + taux_tva / 100)
    return res

print(prix_ttc(50, 10))
print(prix_ttc(100))

Le programme affiche successivement 55.0 et 120.0.

Analyse d'erreur de type en Python

Un élève propose le code Python suivant :

annee_naissance = input("Votre année de naissance : ")
age = 2026 - annee_naissance
print("Vous avez", age, "ans.")

Expliquer l'erreur produite lors de l'exécution et proposer une version corrigée en Python.

Correction

input() renvoie une chaîne de caractères (str). On ne peut pas effectuer une soustraction entre un nombre entier et du texte : Python produit une TypeError.

Code Python corrigé :

annee_naissance = int(input("Votre année de naissance : "))
age = 2026 - annee_naissance
print("Vous avez", age, "ans.")

LP2 : tests en Python

Tests et opérateurs booléens en Python

On considère les variables suivantes :

age = 17
note = 12
absences = 3

Pour chacune des expressions suivantes, indiquer si Python renvoie True ou False. 

age < 18

note >= 10

absences == 0

note != 12

age >= 16 and note >= 10

age >= 18 or note >= 10

note > 15 or absences < 5

Écrire ensuite une expression Python permettant de tester si :

  1. l'élève est majeur ;
  2. la note est comprise entre 10 et 15 inclus ;
  3. l'élève a moins de 5 absences et une note supérieure ou égale à 10 ;
  4. l'élève a une note inférieure à 10 ou au moins 5 absences ;
  5. la note est différente de 0.

Correction

Valeurs des expressions :

age < 18
# True

note >= 10
# True

absences == 0
# False

note != 12
# False

age >= 16 and note >= 10
# True

age >= 18 or note >= 10
# True

note > 15 or absences < 5
# True

Expressions à écrire :

# L'élève est majeur
age >= 18

# La note est comprise entre 10 et 15 inclus
10 <= note <= 15

# Moins de 5 absences ET note supérieure ou égale à 10
absences < 5 and note >= 10

# Note inférieure à 10 OU au moins 5 absences
note < 10 or absences >= 5

# La note est différente de 0
note != 0

Gaming : déterminer le rang d'un joueur

Dans un jeu vidéo, on souhaite déterminer le rang obtenu par un joueur à la fin d'une partie.

On dispose des informations suivantes :

  • score : nombre de points obtenus ;
  • vies : nombre de vies restantes ;
  • boss : booléen qui vaut True si le boss final a été vaincu ;
  • temps : durée de la partie en minutes.

Le rang est déterminé selon les règles suivantes :

  • si le joueur n'a plus de vie, il obtient le rang "GAME OVER", quels que soient ses autres résultats ;
  • il obtient le rang "S" s'il a vaincu le boss, possède au moins 2 vies restantes, a obtenu au moins 10 000 points et a terminé la partie en moins de 30 minutes ;
  • il obtient le rang "A" s'il a vaincu le boss et possède au moins 8 000 points, ou s'il possède au moins 12 000 points ;
  • il obtient le rang "B" s'il possède au moins 5 000 points et au moins une vie restante ;
  • dans tous les autres cas, il obtient le rang "C".

Écrire une fonction rang_joueur(score, vies, boss, temps) qui renvoie le rang obtenu par le joueur.

La fonction devra utiliser if, elif, else, ainsi que les opérateurs and et or.

Tester ensuite la fonction avec les appels suivants :

print(rang_joueur(15000, 0, True, 20))
print(rang_joueur(11000, 3, True, 25))
print(rang_joueur(9000, 1, True, 40))
print(rang_joueur(12500, 1, False, 50))
print(rang_joueur(6500, 2, False, 35))
print(rang_joueur(3000, 3, False, 20))

Pour chacun des appels, prévoir le résultat avant d'exécuter le programme.

Correction

def rang_joueur(score, vies, boss, temps):

    if vies == 0:
        return "GAME OVER"

    elif boss == True and vies >= 2 and score >= 10000 and temps < 30:
        return "S"

    elif (boss == True and score >= 8000) or score >= 12000:
        return "A"

    elif score >= 5000 and vies >= 1:
        return "B"

    else:
        return "C"

Les appels donnent :

print(rang_joueur(15000, 0, True, 20))
# GAME OVER

print(rang_joueur(11000, 3, True, 25))
# S

print(rang_joueur(9000, 1, True, 40))
# A

print(rang_joueur(12500, 1, False, 50))
# A

print(rang_joueur(6500, 2, False, 35))
# B

print(rang_joueur(3000, 3, False, 20))
# C

Attention à l'ordre des conditions : le cas vies == 0 doit être testé en premier. Par exemple, un joueur ayant 15 000 points mais aucune vie restante doit obtenir "GAME OVER" et non le rang "A".

LP3 : les boucles en Python

Réinvestir les fonctions, la boucle bornée for et la boucle conditionnelle while.

Gaming : le raid du donjon

Dans un jeu vidéo, un personnage doit traverser plusieurs vagues de monstres puis vaincre un boss. On souhaite programmer le bilan du raid.

Règles du jeu :

  • Le raid compte n vagues, numérotées de 1 à n.
  • La vague numéro i rapporte 100 + 20 * i points.
  • Le boss possède pv points de vie. Chaque attaque lui retire degats points de vie.
  • Vaincre le boss rapporte un bonus de 500 points. Les points de vie du boss peuvent devenir négatifs à la dernière attaque.

On suppose que n >= 0, pv > 0 et degats > 0.

1. Score des vagues — boucle for. Écrire une fonction score_vagues(n) qui renvoie le total des points obtenus pendant les n vagues. Utiliser for et range. Vérifier que score_vagues(3) renvoie 420.

2. Combat contre le boss — boucle while. Compléter la fonction suivante pour qu'elle renvoie le nombre d'attaques nécessaires pour vaincre le boss. La fonction devra également afficher les PV du boss après chaque attaque.

    def combattre_boss(pv, degats):
        attaques = 0
        while ...:
            pv = ...
            attaques = ...
            print("PV du boss :", pv)
        return ...

Effectuer une trace d'exécution de combattre_boss(25, 8) (valeurs de pv et attaques à chaque tour), puis prévoir la valeur retournée.

3. Fonction de bilan. Écrire la fonction bilan_raid(pv, degats) qui appelle les deux fonctions précédentes et renvoie un couple (score_total, nb_attaques). Le score total comprend les points des vagues et les 500 points de victoire sur le boss.

Prévoir le résultat de bilan_raid(25, 8), puis tester le programme.

4. Réflexion. Pourquoi une boucle for est-elle adaptée aux vagues et une boucle while au combat contre le boss ? Que se passe-t-il si on oublie de diminuer pv dans la boucle ?

Correction

1. Score des vagues :

    def score_vagues(n):
        score = 0
        for i in range(1, n + 1):
            score = score + 100 + 20 * i
        return score

    print(score_vagues(3))  # 420

Pour les vagues 1, 2 et 3 : 120 + 140 + 160 = 420.

2. Combat contre le boss :

    def combattre_boss(pv, degats):
        attaques = 0
        while pv > 0:
            pv = pv - degats
            attaques = attaques + 1
            print("PV du boss :", pv)
        return attaques

Trace de combattre_boss(25, 8) :

    Attaque | PV après attaque | attaques
    --------------------------------------
    1       | 17              | 1
    2       | 9               | 2
    3       | 1               | 3
    4       | -7              | 4

La fonction affiche successivement 17, 9, 1, -7, puis renvoie 4. La condition pv > 0 devient fausse.

3. Bilan du raid :

    def bilan_raid(n, pv, degats):
        return score_vagues(combattre_boss(pv, degats)) + 500,combattre_boss(pv, degats)
        

    print(bilan_raid(25, 8))  # (920, 4)

Le raid rapporte 420 + 500 = 920 points et le boss est vaincu en 4 attaques. Les affichages des PV du boss apparaissent avant celui du bilan.

4. Choix des boucles : le nombre de vagues est connu à l'avance (for) ; le nombre d'attaques dépend des PV du boss (while). Sans diminution de pv, la condition reste vraie : la boucle peut devenir infinie.