WarmUp : 1 NSI

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) ?

É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
                

É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
                

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.

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

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).

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
                

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).

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

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.

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

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.

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

print(celsius_vers_fahrenheit(20))
                

É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.

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))
                

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.

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

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.

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

# 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

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.

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"

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