Langages et programmation

Écrire une fonction signe(x) qui renvoie la chaîne "positif" si $x > 0$, "negatif" si $x < 0$, et "nul" si $x = 0$. Écrire ensuite trois instructions assert pour vérifier votre fonction.

Écris un programme Python qui :

1. demande à l'utilisateur de saisir une distance parcourue en kilomètres, puis un temps de trajet en heures ;
2. calcule la vitesse moyenne correspondante (en km/h) ;
3. affiche cette vitesse moyenne arrondie à deux décimales ;
4. indique, selon la vitesse moyenne obtenue, le mode de déplacement le plus probable, avec les seuils suivants :
   • à pied si $v \leqslant 6$ km/h ;
   • à vélo si $6 < v \leqslant 25$ km/h ;
   • en voiture si $v > 25$ km/h.

Partie A. Écris un programme Python qui lit trois nombres entiers non nuls saisis par l'utilisateur, et affiche "oui" si l'un des trois est un multiple exact des deux autres à la fois, "non" sinon.

Partie B. Écris un programme Python qui saisit un entier s représentant un score, et qui affiche :

• "Échec" si $s < 40$,
• "Moyen" si $40 \leqslant s < 60$,
• "Bien" si $60 \leqslant s < 80$,
• "Excellent" si $s \geqslant 80$.

D'après des fiches d'exercices de NSI Première.

1. Calculatrice. L'utilisateur saisit deux nombres et une opération (+, -, * ou /). Le programme affiche le calcul et son résultat avec quatre décimales, par exemple :

Nombre 1 : 13.2
Opération (+, -, * ou /) : /
Nombre 2 : 3
13.2000 / 3.0000 = 4.4000

Prévoir les cas d'une opération inconnue et d'une division par zéro.

2. Jury d'examen. Un candidat passe trois épreuves. Il est admis :

• soit s'il a obtenu au moins 9 à chacune des trois épreuves ;
• soit si la moyenne de ses trois notes est au moins égale à 10 et que sa plus basse note est au moins égale à 8.

Sinon, il est refusé. Écrire un programme qui fait saisir le nom du candidat et ses trois notes, puis affiche la décision. Que décide le jury pour un candidat ayant obtenu 10,5 ; 7 et 12 ? Et pour 8 ; 12 et 11 ?

D'après des séries d'exercices de NSI Première.

1. Durée. Écrire un programme qui demande un nombre de minutes et l'affiche en heures et minutes : 135 minutes donnent « 2 heures et 15 minutes ».
2. Parité. Écrire un programme qui demande un entier et affiche s'il est pair ou impair.
3. Échange. On saisit deux valeurs a et b. Échanger leurs contenus, puis les afficher : avec a = 5 et b = 3, on doit obtenir a = 3 et b = 5. Pourquoi les deux instructions a = b puis b = a ne conviennent-elles pas ?
4. Température. Convertir en degrés Fahrenheit une température saisie en degrés Celsius, avec $F = C \times \dfrac{9}{5} + 32$. Que donnent 37 °C ? −40 °C ?
5. Âge. Demander son âge à l'utilisateur et afficher son année de naissance, en supposant que l'on est en 2024. Pourquoi le résultat peut-il être faux d'un an ?

D'après des séries d'exercices de NSI Première.

1. Année bissextile. Une année est bissextile si elle est divisible par 4 mais pas par 100, sauf si elle est divisible par 400. Écrire une fonction bissextile(annee) qui renvoie un booléen, et la tester sur 2024, 2023, 1900 et 2000.
2. Trois nombres. Écrire une fonction trier3(a, b, c) qui renvoie les trois nombres rangés du plus petit au plus grand, sans utiliser sorted, sort, min ni max.
3. Appréciation. Écrire une fonction qui renvoie l'appréciation d'une note sur 20 : « Insuffisant » en dessous de 10, « Assez bien » de 10 inclus à 15 exclu, « Bien » de 15 inclus à 18 exclu, « Excellent » à partir de 18.
4. Impôt. Un barème indique : pas d'impôt en dessous de 10 000 € de revenu annuel ; 10 % entre 10 000 € et 25 000 € ; 20 % au-delà de 25 000 €.
   • a. On l'interprète d'abord ainsi : on repère la tranche du revenu, puis on applique son taux au revenu entier. Écrire la fonction impot(revenu) correspondante. Calculer l'impôt pour 25 000 € puis pour 25 001 €. Que constate-t-on ?
   • b. Dans un barème progressif, chaque taux ne s'applique qu'à la part du revenu située dans sa tranche. Écrire impot_progressif(revenu) et calculer l'impôt pour 20 000 € et pour 30 000 €.

D'après des séries d'exercices de NSI Première.

Au jeu de pierre-feuille-ciseaux, la pierre bat les ciseaux, les ciseaux battent la feuille, et la feuille bat la pierre ; deux coups identiques donnent une égalité.

1. Écrire une fonction gagnant(coup1, coup2) qui renvoie 1 si le premier coup gagne, 2 si le second gagne, 0 en cas d'égalité. Les coups sont les chaînes "pierre", "feuille" et "ciseaux".
2. Écrire un programme qui fait jouer l'utilisateur contre l'ordinateur, qui choisit son coup au hasard, en cinq manches, puis affiche le score final.

1. Écrire une fonction somme_for(n) qui calcule $1 + 2 + \cdots + n$ à l'aide d'une boucle for.
2. Écrire une fonction somme_while(n) qui calcule le même résultat à l'aide d'une boucle while.
3. Vérifier que somme_for(10) et somme_while(10) renvoient bien $55$.

Partie A/B. Écris un programme qui demande à l'utilisateur de saisir un nombre entier positif N, calcule la somme des N premiers nombres impairs ($1, 3, 5, \dots$) une première fois à l'aide d'une boucle for i in range(...), puis une seconde fois à l'aide d'une boucle while, et affiche les deux résultats.

Partie C. Écris une fonction est_decroissant(T) qui prend une liste T en entrée et retourne True si ses éléments sont triés en ordre strictement décroissant, False sinon.

Exemples : est_decroissant([9, 7, 5, 3, 1]) doit renvoyer True ; est_decroissant([10, 8, 6, 7, 4]) doit renvoyer False.

D'après un devoir surveillé de NSI Première (2020-2021).

Pour chaque question, une seule proposition est exacte.

Question 1. Quelle valeur affiche ce programme ?

x = 1
for i in range(10):
    x = x * 2
print(x)

A. 1024 — B. 2 — C. 20000000000 — D. 2048

Question 2. On veut afficher tous les nombres pairs de 0 à 152. Par quoi remplacer la ligne en pointillés ?

n = 0
......................
    print(n)
    n = n + 2

A. for i in range(152): — B. for n in range(153): — C. while n <= 152: — D. while n < 151:

Question 3. On considère la fonction suivante, où capital et interet sont des nombres strictement positifs.

def capital_double(capital, interet):
    n = 0
    montant = capital
    while montant <= 2 * capital:
        montant = montant + interet
        n = n + 1
    return n

Que peut-on toujours affirmer à propos du nombre n renvoyé ?

A. capital * n * interet > 2 * capital

B. n == 2 * capital / interet

C. capital + n * interet > 2 * capital

D. n == capital / interet

D'après un devoir surveillé de NSI Première (2020-2021).

La fonction suivante doit indiquer si un entier a supérieur à 2 est premier, ou bien afficher l'un de ses diviseurs.

from math import sqrt
 
def premier(a):
    i = 2
    while a % i != 0:
        i = i + 1
        if i > sqrt(a):
            print(...)
            i = a
    if ...:
        print("Le nombre", a, "est divisible par", i)

1. À quoi sert la boucle while (ligne while a % i != 0:) ?
2. Compléter l'instruction print(...).
3. Compléter la condition if ...: de l'avant-dernière ligne.
4. Dérouler l'appel premier(9), puis l'appel premier(7).

D'après des fiches d'exercices de NSI Première.

1. Écrire un programme qui fait saisir un entier naturel n, puis affiche sa table de multiplication de 0 à 11, sous la forme 0 * 17 = 0, 1 * 17 = 17, etc.

2. Écrire un programme qui réalise l'affichage suivant :

*****
****
***
**
*

3. Écrire un programme qui fait saisir un entier N supérieur ou égal à 2, puis affiche un triangle « vide » de hauteur N. Pour N = 5 :

*
**
* *
*  *
*****

D'après des séries d'exercices de NSI Première.

1. Valeur sentinelle. Écrire un programme qui fait saisir des notes, entre 0 et 20, sans savoir à l'avance combien il y en aura. La saisie s'arrête quand l'utilisateur entre −1 ; une note hors de l'intervalle est refusée. Le programme affiche alors la moyenne des notes saisies. Pourquoi faut-il ici une boucle while ? Quel cas particulier faut-il traiter ?
2. Analyse d'un texte. Écrire un programme qui fait saisir une phrase, puis affiche son nombre de mots, son nombre de voyelles et son mot le plus long. Que donne-t-il pour « Le petit chat dort sur le canapé » ?

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°12, exercice 2.

Le jeu du « plus ou moins » consiste à deviner un nombre entier choisi entre 1 et 99. Une élève de NSI décide de le coder en langage Python de la manière suivante :

• le programme génère un nombre entier aléatoire compris entre 1 et 99 ;
• si la proposition de l'utilisatrice est plus petite que le nombre cherché, l'utilisatrice en est avertie ; elle peut alors en tester un autre ;
• si la proposition de l'utilisatrice est plus grande que le nombre cherché, l'utilisatrice en est avertie ; elle peut alors en tester un autre ;
• si l'utilisatrice trouve le bon nombre en 10 essais ou moins, elle gagne ;
• si l'utilisatrice a fait plus de 10 essais sans trouver le bon nombre, elle perd.

La fonction randint est utilisée : si a et b sont des entiers tels que a <= b, randint(a, b) renvoie un nombre entier compris entre a et b inclus.

Compléter le code ci-dessous et le tester :

from random import randint
 
def plus_ou_moins():
    nb_mystere = randint(1, ...)
    nb_test = int(input("Proposez un nombre entre 1 et 99 : "))
    compteur = ...
 
    while nb_mystere != ... and compteur < ...:
        compteur = compteur + 1
        if nb_mystere ... nb_test:
            nb_test = int(input("Trop petit ! Testez encore : "))
        else:
            nb_test = int(input("Trop grand ! Testez encore : "))
 
    if nb_mystere == nb_test:
        print ("Bravo ! Le nombre était ", ...)
        print("Nombre d'essais: ", ...)
    else:
        print ("Perdu ! Le nombre était ", ...)

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°18, exercice 1.

Programmer la fonction multiplication qui prend en paramètres deux nombres entiers relatifs n1 et n2, et qui renvoie le produit de ces deux nombres.

Les seules opérations arithmétiques autorisées sont l'addition et la soustraction.

Exemples :

>>> multiplication(3, 5)
15
>>> multiplication(-4, -8)
32
>>> multiplication(-2, 6)
-12
>>> multiplication(-2, 0)
0

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°19, exercice 1.

On rappelle que :

• le nombre $a^n$ est le nombre $a \times a \times a \times \cdots \times a$, où le facteur $a$ apparaît $n$ fois ;
• en langage Python, l'instruction t[-1] permet d'accéder au dernier élément du tableau t.

Dans cet exercice, l'opérateur ** et la fonction pow ne sont pas autorisés.

Programmer en langage Python une fonction liste_puissances qui prend en argument un nombre entier $a$, un entier strictement positif $n$ et qui renvoie la liste de ses puissances $[a^1, a^2, \ldots, a^n]$.

Programmer également une fonction liste_puissances_borne qui prend en argument un nombre entier $a$ supérieur ou égal à 2 et un entier borne, et qui renvoie la liste de ses puissances, à l'exclusion de $a^0$, strictement inférieures à borne.

Exemples :

>>> liste_puissances(3, 5)
[3, 9, 27, 81, 243]
>>> liste_puissances(-2, 4)
[-2, 4, -8, 16]
>>> liste_puissances_borne(2, 16)
[2, 4, 8]
>>> liste_puissances_borne(2, 17)
[2, 4, 8, 16]
>>> liste_puissances_borne(5, 5)
[]

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°26, exercice 2.

On considère une piste carrée qui contient 4 cases par côté. Les cases sont numérotées de 0 inclus à 12 exclu comme ci-dessous :

+----+----+----+----+
|  0 |  1 |  2 |  3 |
+----+----+----+----+
| 11 |         |  4 |
+----+         +----+
| 10 |         |  5 |
+----+----+----+----+
|  9 |  8 |  7 |  6 |
+----+----+----+----+

L'objectif de l'exercice est d'implémenter le jeu suivant :

Au départ, le joueur place son pion sur la case 0. À chaque coup, il lance un dé équilibré à six faces et avance son pion d'autant de cases que le nombre indiqué par le dé (entre 1 et 6 inclus) dans le sens des aiguilles d'une montre.

Par exemple, s'il obtient 2 au premier lancer, il pose son pion sur la case 2 puis s'il obtient 6 au deuxième lancer, il le pose sur la case 8, puis s'il obtient à nouveau 6, il pose le pion sur la case 2.

Le jeu se termine lorsque le joueur a posé son pion sur toutes les cases de la piste.

Compléter la fonction nombre_coups ci-dessous de sorte qu'elle renvoie le nombre de lancers aléatoires nécessaires pour terminer le jeu.

Proposer ensuite quelques tests pour en vérifier le fonctionnement.

from random import randint
 
def nombre_coups():
    '''Simule un jeu de plateau avec 12 cases et renvoie le nombre
    minimal de coups pour visiter toutes les cases.'''
    nombre_cases = 12
    # indique si une case a été vue
    cases_vues = [ False ] * nombre_cases
    nombre_cases_vues = 1
    cases_vues[0] = True
    case_en_cours = 0
    n = ...
    while ... < ...:
        x = randint(1, 6)
        case_en_cours = (case_en_cours + ...) % ...
        if ...:
            cases_vues[case_en_cours] = True
            nombre_cases_vues = ...
        n = ...
    return n

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°33, exercice 1.

Programmer une fonction renverse, prenant en paramètre une chaîne de caractères non vide mot et renvoie cette chaîne de caractères en ordre inverse.

Exemple :

>>> renverse("")
''
>>> renverse("abc")
'cba'
>>> renverse("informatique")
'euqitamrofni'

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°48, exercice 2.

On considère dans cet exercice la suite de nombres suivante : 1, 11, 21, 1211, 111221, …

Cette suite est construite ainsi : pour passer d'une valeur à la suivante, on la lit et on l'écrit sous la forme d'un nombre. Ainsi, pour 1211 :

• on lit un 1, un 2, deux 1 ;
• on écrit donc en nombre 1 1, 1 2, 2 1 ;
• puis on concatène 111221.

Compléter la fonction nombre_suivant qui prend en entrée un nombre sous forme de chaîne de caractères et qui renvoie le nombre suivant par ce procédé, encore sous forme de chaîne de caractères.

def nombre_suivant(s):
    '''Renvoie le nombre suivant de celui representé par s
    en appliquant le procédé de lecture.'''
    resultat = ''
    chiffre = s[0]
    compte = 1
    for i in range(...):
        if s[i] == chiffre:
            compte = ...
        else:
            resultat += ... + ...
            chiffre = ...
            ...
    lecture_... = ... + ...
    resultat += lecture_chiffre
    return resultat

Exemples :

>>> nombre_suivant('1211')
'111221'
>>> nombre_suivant('311')
'1321'

Banque nationale de sujets 2026 de l'épreuve pratique, sujet n°17 (situation d'évaluation d'une heure).

Budget d'un club de handball

Un club de handball professionnel souhaite mieux comprendre et gérer ses dépenses et recettes annuelles. Les dirigeants veulent identifier les postes de dépenses les plus importants et s'assurer de l'exactitude de leur solde budgétaire de fin d'année.

On dispose de jeux de données sous forme de fichiers CSV représentant les mouvements budgétaires du club. Chaque mouvement est décrit par un enregistrement comportant les attributs suivants :

• 'type' : chaîne de caractères dont les valeurs possibles sont 'dépense' ou 'recette' ;
• 'catégorie' : chaîne de caractères dont les valeurs possibles sont 'subventions', 'sponsoring', 'billetterie', 'marketing', 'salaires', 'déplacements', 'fonctionnement', 'cotisations' ou 'autres_charges' ;
• 'montant' : nombre flottant positif représentant la somme en euros ;
• 'mois' : nombre entier compris entre 1 et 12.

Une fois chargés par le script analyse_budget.py, ces jeux de données donnent une liste de dictionnaires mouvements. Deux jeux de données sont fournis :

• un jeu de test défini directement dans le code dans la variable mouvements_test ;
• un jeu complet budget_complet.csv de plus de 2 000 mouvements.

Le fichier analyse_budget.py contient plusieurs fonctions d'analyse que le sujet vise à compléter.

Question 1. Écrire la fonction total_par_type(mouvements, type_mouvement) qui prend en paramètres une liste de mouvements et une chaîne de caractères (parmi 'dépense' ou 'recette'). Cette fonction doit renvoyer la somme totale des montants correspondant à ce type précis. La fonction renverra 0 si aucun mouvement ne correspond. Créer ensuite une fonction test_total() contenant au moins deux assertions pour valider le bon fonctionnement de votre code sur le jeu de données mouvements_test (par exemple, le total des recettes attendu est de 2300.0).

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

La fonction solde_annuel(mouvements), déjà codée dans le fichier fourni, est censée calculer le bilan financier de l'année en faisant la somme des soldes de chaque mois (recettes totales moins dépenses totales). Si le solde annuel est positif, le club dégage des bénéfices. S'il est négatif, le club est en déficit.

Question 2. Calculer manuellement le solde annuel attendu pour la liste mouvements_test. Écrire ensuite une fonction test_solde_annuel() contenant une assertion qui vérifie que la fonction solde_annuel(mouvements_test) renvoie bien ce résultat théorique. Exécuter ce test.

L'exécution du test précédent lève une erreur : le résultat renvoyé par la fonction solde_annuel ne correspond pas à la réalité comptable.

Question 3. Analyser le code de la fonction solde_annuel pour identifier la source de cette erreur logique, expliquer pourquoi certains mouvements ont été ignorés, puis proposer une correction. Appliquer ensuite votre fonction corrigée sur le fichier budget_complet.csv pour annoncer le véritable solde du club au professeur.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Fichiers fournis

Le dossier comporte une version PDF de l'énoncé, le code source à analyser et compléter analyse_budget.py et le jeu de données complet budget_complet.csv (2 026 mouvements).

analyse_budget.py

import csv
 
 
def lire_mouvements_depuis_csv(nom_fichier_csv):
    """
    Lit les données d'un fichier CSV et les retourne en liste de dictionnaires.
    Les colonnes 'montant' et 'mois' sont converties respectivement en flottant et en entier.
    """
    mouvements_csv = []
    try:
        with open(nom_fichier_csv, mode='r', newline='', encoding='utf-8') as fichier_csv:
            lecteur_csv = csv.DictReader(fichier_csv)
            for ligne in lecteur_csv:
                ligne['montant'] = float(ligne['montant'])
                ligne['mois'] = int(ligne['mois'])
                mouvements_csv.append(ligne)
        return mouvements_csv
    except FileNotFoundError:
        print(f"Erreur : Le fichier '{nom_fichier_csv}' est introuvable.")
        return []
 
 
mouvements_test = [
    {'type': 'recette', 'catégorie': 'cotisations', 'montant': 1200.0, 'mois': 1},
    {'type': 'recette', 'catégorie': 'billetterie', 'montant': 300.0, 'mois': 6},
    {'type': 'dépense', 'catégorie': 'fonctionnement', 'montant': 450.0, 'mois': 6},
    {'type': 'dépense', 'catégorie': 'déplacements', 'montant': 200.0, 'mois': 12},
    {'type': 'dépense', 'catégorie': 'salaires', 'montant': 1500.0, 'mois': 12},
    {'type': 'recette', 'catégorie': 'subventions', 'montant': 800.0, 'mois': 12}
]
 
#############################################################################
# Écrire ci-dessous la fonction total_par_type et ses tests (Question 1)    #
#############################################################################
 
 
#############################################################################
# Fonctions de calcul du solde (Questions 2 et 3)                           #
#############################################################################
 
def solde_mensuel(mouvements, mois):
    """
    Calcule le solde pour un mois donné (recettes - dépenses).
    """
    total_recettes = 0
    total_depenses = 0
 
    for m in mouvements:
        if m['mois'] == mois:
            if m['type'] == 'recette':
                total_recettes += m['montant']
            else:
                total_depenses += m['montant']
 
    return total_recettes - total_depenses
 
 
def solde_annuel(mouvements):
    """
    Calcule le solde annuel en additionnant les soldes de chaque mois.
    """
    total = 0
    # Parcourt les mois de l'année pour cumuler le bilan
    for m in range(1, 12):
        total = total + solde_mensuel(mouvements, m)
 
    return total
 
 
#############################################################################
# Écrire ci-dessous la fonction test_solde_annuel (Question 2)              #
#############################################################################
 
 
#############################################################################
# Programme principal pour analyser le fichier complet                      #
#############################################################################
 
# mouvements_complets = lire_mouvements_depuis_csv("budget_complet.csv")
# print("Le solde annuel sur le fichier complet est de :", solde_annuel(mouvements_complets))

budget_complet.csv (début du fichier)

type,catégorie,montant,mois
dépense,autres_charges,269.87,1
dépense,autres_charges,165.32,1
dépense,autres_charges,320.95,1
dépense,autres_charges,259.87,1
dépense,autres_charges,100.52,1
...

1. Écrire une fonction mention(note) qui renvoie la chaîne "Très bien" si $note \geqslant 16$, "Bien" si $14 \leqslant note < 16$, "Assez bien" si $12 \leqslant note < 14$, et "Passable" sinon.
2. Écrire une fonction note_finale(controle, examen) qui calcule une moyenne pondérée ($30\%$ pour le contrôle, $70\%$ pour l'examen) et renvoie à la fois la moyenne et sa mention (en appelant mention).
3. Tester note_finale(10, 16) : que renvoie-t-elle ?

Écris une fonction surface_carre(c) qui calcule et retourne la surface d'un carré de côté c (formule $\text{Surface} = c^2$). Écris ensuite un programme principal qui demande à l'utilisateur de saisir la longueur du côté du carré, appelle la fonction surface_carre() pour calculer la surface, puis affiche le résultat.

On travaille avec des coordonnées représentées sous forme de tuples (x, y, z), correspondant à des points en 3D :

points3D = [(1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12)]

1. Écris une fonction decompose(points) qui prend en paramètre une liste de tuples (x, y, z) et renvoie trois listes distinctes X, Y, Z. Exemple attendu : decompose(points3D) renvoie X=[1, 4, 7, 10], Y=[2, 5, 8, 11], Z=[3, 6, 9, 12].
2. Écris une fonction recompose(X, Y, Z) qui prend ces trois listes et les fusionne pour reconstruire la liste de tuples initiale. Exemple attendu : recompose(X, Y, Z) renvoie [(1, 2, 3), (4, 5, 6), (7, 8, 9), (10, 11, 12)].

D'après des séries d'exercices de NSI Première.

Écrire les fonctions suivantes, puis les tester sur des exemples bien choisis.

1. compter_voyelles(chaine) renvoie le nombre de voyelles de la chaîne, minuscules ou majuscules, accentuées ou non.
2. est_palindrome(mot) renvoie True si le mot se lit de la même façon dans les deux sens, comme « radar » ou « kayak ».
3. est_premier(n) renvoie True si l'entier n est premier, c'est-à-dire s'il a exactement deux diviseurs, 1 et lui-même.
4. mot_le_plus_long(mots) renvoie le mot le plus long d'une liste non vide (le premier rencontré en cas d'égalité).
5. mot_de_passe_valide(mdp) renvoie True si le mot de passe compte au moins 8 caractères et contient au moins un chiffre.
6. factorielle(n) renvoie $n! = 1 \times 2 \times \dots \times n$, avec la convention $0! = 1$.

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°35, exercice 2.

Un mot palindrome peut se lire de la même façon de gauche à droite ou de droite à gauche : kayak, radar, et non sont des mots palindromes.

De même certains nombres ont des écritures décimales qui sont des palindromes : 33, 121, 345543.

L'objectif de cet exercice est d'obtenir un programme Python permettant de tester si un nombre est un nombre palindrome.

Pour remplir cette tâche, on vous demande de compléter le code des trois fonctions ci-dessous qui s'appuient les unes sur les autres :

• inverse_chaine : qui renvoie une chaîne de caractères inversée ;
• est_palindrome : qui teste si une chaîne de caractères est un palindrome ;
• est_nbre_palindrome : qui teste si un nombre est un palindrome.

Compléter le code des trois fonctions ci-dessous.

def inverse_chaine(chaine):
    '''Retourne la chaine inversée'''
    resultat = ...
    for caractere in chaine:
        resultat = ...
    return resultat
 
def est_palindrome(chaine):
    '''Renvoie un booléen indiquant si la chaine ch
    est un palindrome'''
    inverse = inverse_chaine(chaine)
    return ...
 
def est_nbre_palindrome(nbre):
    '''Renvoie un booléen indiquant si le nombre nbre
    est un palindrome'''
    chaine = ...
    return est_palindrome(chaine)

Exemples :

>>> inverse_chaine('bac')
'cab'
>>> est_palindrome('NSI')
False
>>> est_palindrome('ISN-NSI')
True
>>> est_nbre_palindrome(214312)
False
>>> est_nbre_palindrome(213312)
True

On donne la fonction Python suivante :

def est_majeur(age):
    """Renvoie True si age est superieur ou egal a 18, False sinon."""
    if age >= 18:
        return True
    else:
        return False

1. Traduire cette fonction en JavaScript (mots-clés function, accolades, return).
2. Traduire cette fonction en pseudo-code.
3. Lister trois traits communs et deux traits spécifiques entre les trois versions.

On donne la fonction JavaScript suivante :

function sommeJusqua(n) {
    var somme = 0;
    var i = 1;
    while (i <= n) {
        somme = somme + i;
        i = i + 1;
    }
    return somme;
}

1. Que calcule cette fonction ? Dérouler l'exécution de sommeJusqua(4) en indiquant les valeurs de somme et i à chaque tour de boucle, jusqu'à l'arrêt.
2. Traduire cette fonction en Python (sans mot-clé var, avec les deux-points et l'indentation attendus).
3. S'agit-il ici d'une boucle bornée ou d'une boucle non bornée ? Justifier en comparant avec la boucle for utilisée dans le cours.
4. Citer un trait spécifique à JavaScript utilisé dans ce code et absent en Python (parmi ceux vus dans le cours).

On donne l'algorithme suivant en pseudo-code, qui affiche si un nombre est pair ou impair :

Fonction parite(nombre)
    Si nombre % 2 == 0 alors
        Afficher "pair"
    Sinon
        Afficher "impair"
    FinSi
FinFonction

1. Traduire cet algorithme en Python.
2. Scratch est un langage à blocs (vu dans le cours) : il n'y a pas de code textuel, on assemble des blocs visuels. Décrire, en une phrase pour chacun, les blocs Scratch qui joueraient le même rôle que la structure Si ... alors ... Sinon ... FinSi, que le test nombre % 2 == 0, et que l'instruction Afficher.
3. À quoi correspond l'opération % (modulo) sur les nombres 7 et 2 ? Sur 8 et 2 ?
4. Cet algorithme utilise-t-il une boucle ? Justifier en listant les constructions élémentaires réellement présentes, parmi : variable, condition, boucle, fonction, affichage.

On veut écrire une fonction qui renvoie l'indice de l'élément maximum d'une liste de nombres.

1. Écrire le prototype de la fonction indice_du_maximum(tab), avec sa précondition et sa postcondition, sous forme de docstring.
2. Implémenter la fonction en Python, en utilisant assert pour vérifier la précondition.
3. Vérifier avec assert que indice_du_maximum([3, 7, 2, 7, 1]) renvoie bien 1 (le premier indice où le maximum $7$ apparaît).

On donne la fonction Python suivante, déjà implémentée mais sans aucune documentation :

def moyenne(notes):
    total = 0
    for note in notes:
        total = total + note
    return total / len(notes)

1. Que se passe-t-il si on appelle moyenne([]) (liste vide) ? Détailler précisément quelle opération pose problème, et quelle erreur Python génère.
2. En déduire une précondition raisonnable sur le paramètre notes.
3. Écrire une postcondition qui décrit ce que renvoie la fonction (on pourra utiliser le vocabulaire « moyenne arithmétique »).
4. Réécrire la fonction avec sa docstring (précondition et postcondition) et un assert qui vérifie la précondition en tout début de fonction.
5. Avec la précondition ajoutée, que se passe-t-il désormais si on appelle moyenne([]) ?

On veut écrire une fonction division_entiere(a, b) qui calcule le quotient q et le reste r de la division euclidienne de a par b, pour a un entier positif ou nul et b un entier strictement positif. Elle doit renvoyer le couple (q, r).

1. Rappeler la propriété mathématique qui définit le quotient et le reste d'une division euclidienne de a par b (relation entre a, b, q et r, et encadrement de r).
2. Écrire la précondition de division_entiere(a, b) (deux conditions, une sur a et une sur b).
3. Écrire la postcondition, en utilisant la propriété rappelée à la question 1.
4. Implémenter la fonction en Python sans utiliser les opérateurs // et % (on utilisera une boucle qui soustrait b autant de fois que possible), avec un assert qui vérifie la précondition.
5. Dérouler l'exécution de division_entiere(17, 5) : donner la valeur de q et r à chaque tour de boucle, jusqu'à l'arrêt.

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°37, exercice 1.

Programmer la fonction moyenne prenant en paramètre un tableau d'entiers tab (de type list) qui renvoie la moyenne de ses éléments si le tableau est non vide. Proposer une façon de traiter le cas où le tableau passé en paramètre est vide.

Dans cet exercice, on s'interdira d'utiliser la fonction Python sum.

Exemples :

>>> moyenne([5,3,8])
5.333333333333333
>>> moyenne([1,2,3,4,5,6,7,8,9,10])
5.5
>>> moyenne([])
# Comportement différent suivant le traitement proposé.

1. On donne la fonction est_pair(n) suivante :

def est_pair(n):
    """Renvoie True si n est pair, False sinon."""
    return n % 2 == 0

Écrire un jeu de tests représentatif pour cette fonction (au moins 4 cas, en incluant des cas limites : zéro, un nombre négatif).

2. En utilisant le module random, écrire une fonction lancer_de() qui simule le lancer d'un dé à 6 faces (renvoie un entier entre 1 et 6).

3. Écrire un test adapté à cette fonction (on ne peut pas tester une valeur exacte).

On donne la fonction suivante :

def est_positif(n):
    """Renvoie True si n est positif ou nul, False sinon."""
    return n > 0

1. D'après la docstring, que doit renvoyer est_positif(0) ?
2. Écrire un jeu de tests représentatif pour cette fonction (au moins 4 cas, en incluant les cas limites n = 0 et un nombre négatif).
3. Exécuter mentalement chacun de vos tests. L'un d'eux échoue-t-il ? Si oui, lequel, et pourquoi ?
4. Corriger la fonction pour qu'elle respecte sa docstring.

On veut écrire une fonction distance_a_lorigine() qui tire au hasard un point de coordonnées entières (x, y), avec x et y compris entre -10 et 10 inclus, à l'aide du module random, puis renvoie la distance de ce point à l'origine, calculée avec le module math.

1. Rappeler la formule mathématique de la distance d'un point $(x, y)$ à l'origine.
2. Écrire la fonction distance_a_lorigine(), en utilisant random.randint pour tirer x et y, et une fonction du module math pour calculer la distance.
3. Pourquoi ne peut-on pas tester cette fonction avec un simple assert distance_a_lorigine() == valeur_attendue ?
4. Écrire un test adapté à cette fonction, portant sur des propriétés que le résultat doit toujours vérifier (on pourra s'aider de math.sqrt(200), qui donne la distance maximale possible).
5. Le cours présente une autre fonction du module random, différente de randint. Laquelle, et quelle différence avec randint ?

D'après un devoir surveillé de NSI Première (2020-2021).

Le programme suivant doit faire deviner au joueur un entier choisi au hasard entre 0 et 100 inclus. Il contient quatre erreurs : trois l'empêchent de fonctionner, la quatrième lui fait afficher un message faux. Les trouver et les corriger.

from random import randint
 
def devine():
    """Jeu : deviner un entier choisi au hasard entre 0 et 100 inclus."""
    nbOrdi = random.randint(0, 100)
    nbJoueur = -1
    gagne = False
    # On redemande un nombre tant que la partie n'est pas gagnée
    while gagne = False:
        nbJoueur = int(input("Choisissez un nombre entre 0 et 100 : "))
        if nbJoueur = nbOrdi:
            print("Bravo, vous avez trouvé !")
            gagne = True
        elif nbJoueur < nbOrdi:
            print("Trop petit")
    else:
        print("Trop grand")

Banque nationale de sujets 2024 de l'épreuve pratique, sujet n°31, exercice 1.

Programmer la fonction multiplication, prenant en paramètres deux nombres entiers relatifs n1 et n2, et qui renvoie le produit de ces deux nombres.

Les seules opérations autorisées sont l'addition et la soustraction.

>>> multiplication(3, 5)
15
>>> multiplication(-4, -8)
32
>>> multiplication(-2, 6)
-12
>>> multiplication(-2, 0)
0

Banque nationale de sujets 2026 de l'épreuve pratique, sujet n°18 (situation d'évaluation d'une heure).

Températures océaniques en Polynésie

En Polynésie française, un réseau de bouées océanographiques mesure quotidiennement la température de surface de l'océan dans quatre archipels : Société, Tuamotu, Marquises et Australes. Ces données permettent de documenter le réchauffement climatique dans le Pacifique Sud. Vous êtes chargé(e) de développer des outils d'analyse pour traiter ces relevés et détecter les anomalies thermiques.

On vous fournit le fichier analyse_temperatures_polynesie.py dans lequel figurent les données à utiliser, ainsi que les fonctions à écrire, compléter ou corriger.

Question 1. Écrire une fonction temperature_moyenne(zone, donnees) qui :

• prend en paramètres une chaîne zone (nom d'un archipel) et un tableau donnees de dictionnaires représentant les relevés ;
• renvoie la température moyenne (float) pour cette zone ;
• renvoie None si la zone n'a aucun relevé.

Exemple :

>>> donnees = [
    {'date': '2020-01-15', 'zone': 'Societe', 'temperature': 28.5},
    {'date': '2020-01-16', 'zone': 'Societe', 'temperature': 29.0},
    {'date': '2020-01-15', 'zone': 'Tuamotu', 'temperature': 27.5}
]
>>> temperature_moyenne('Societe', donnees)
28.75
>>> temperature_moyenne('Marquises', donnees)
>>>

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Question 2. Écrire une fonction detecter_anomalies(zone, seuil, donnees) qui :

• prend en paramètres une zone, un seuil (float) et la liste donnees ;
• calcule la température moyenne de la zone ;
• renvoie la liste des dates où la température s'écarte de plus de seuil degrés (en valeur absolue, via la fonction abs()) de cette moyenne ;
• renvoie une liste vide si la zone n'existe pas.

Exemple avec la liste donnees_test fournie dans le script :

>>> detecter_anomalies('Societe', 1.0, donnees_test)
['2010-06-20', '2021-05-30']

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Dans le fichier analyse_temperatures_polynesie.py figure le code de la fonction evolution_par_decennie(zone, donnees) censée calculer l'évolution des températures moyennes par décennie (2010, 2020).

Question 3. Compléter les trois fonctions de test, situées à la fin du fichier, pour la fonction evolution_par_decennie en utilisant le jeu de données fourni :

1. test_zone_inexistante() : tester une zone qui n'existe pas ;
2. test_une_seule_decennie() : tester une zone avec données sur une seule décennie ;
3. test_plusieurs_decennies() : tester une zone avec données sur plusieurs décennies.

Vos tests doivent permettre d'identifier le bug présent dans le code.

Question 4. Après avoir identifié le bug grâce à vos tests, corriger la fonction evolution_par_decennie.

Appel professeur — Appeler le professeur pour lui présenter votre réponse ou en cas de difficulté.

Fichier fourni : analyse_temperatures_polynesie.py

# =================================================================================#
# Données de test
donnees_test = [
    # Société - Données sur 2010 et 2020
    {'date': '2010-01-15', 'zone': 'Societe', 'temperature': 27.0},
    {'date': '2010-06-20', 'zone': 'Societe', 'temperature': 26.5},
    {'date': '2011-03-10', 'zone': 'Societe', 'temperature': 27.5},
    {'date': '2020-02-14', 'zone': 'Societe', 'temperature': 28.0},
    {'date': '2020-08-22', 'zone': 'Societe', 'temperature': 28.5},
    {'date': '2021-05-30', 'zone': 'Societe', 'temperature': 29.0},
 
    # Tuamotu - Données sur 2010 et 2020
    {'date': '2015-04-10', 'zone': 'Tuamotu', 'temperature': 26.8},
    {'date': '2020-07-15', 'zone': 'Tuamotu', 'temperature': 27.5},
    {'date': '2021-09-20', 'zone': 'Tuamotu', 'temperature': 28.0},
 
    # Marquises - Données uniquement sur 2020
    {'date': '2020-03-15', 'zone': 'Marquises', 'temperature': 25.5},
    {'date': '2021-07-10', 'zone': 'Marquises', 'temperature': 26.0},
    {'date': '2022-11-25', 'zone': 'Marquises', 'temperature': 26.5},
]
 
# =================================================================================#
#  Question 1 : Ecrire le code de votre fonction température_moyenne
 
 
# =================================================================================#
#  Question 2 : Ecrire le code de votre fonction detection_anomalies
 
 
# =================================================================================#
# code de la fonction evolution_par_decennie à corriger dans la question 4:
 
 
def evolution_par_decennie(zone, donnees):
    """
    Calcule l'évolution des températures moyennes par décennie pour une zone.
 
    ATTENTION: Cette fonction contient un bug volontaire à détecter et corriger.
 
    Arguments:
        zone (str): Nom de l'archipel (ex: 'Societe', 'Tuamotu')
        donnees (list): Liste de dictionnaires de relevés
 
    Renvoie:
        dict: Dictionnaire {décennie : température_moyenne}
              ex: {2010: 27.5, 2020: 28.3}
              Renvoie un dictionnaire vide si la zone n'existe pas
    """
    # Filtrage des relevés pour la zone
    releves_zone = [r for r in donnees if r['zone'] == zone]
 
    if len(releves_zone) == 0:
        return {}
 
    # Regroupement par décennie
    temperatures_par_decennie = {}
 
    for releve in releves_zone:
        # Extraction de l'année de la date (format: 'YYYY-MM-DD')
        annee = int(releve['date'].split('-')[0])
 
        # Calcul de la décennie
        decennie = (annee // 10)
 
        if decennie not in temperatures_par_decennie:
            temperatures_par_decennie[decennie] = []
 
        temperatures_par_decennie[decennie].append(releve['temperature'])
 
    # Calcul des moyennes
    moyennes = {}
    for decennie, temperatures in temperatures_par_decennie.items():
        moyennes[decennie] = round(sum(temperatures) / len(temperatures), 2)
 
    return moyennes
 
 
# =================================================================================#
#  Exercice 2.1 :
"""
Tests
À compléter par le candidat dans le cadre de la question 3
"""
 
 
def test_zone_inexistante():
    """
    Test 1 : Tester une zone qui n'existe pas
 
    À compléter:
    1. Appeler evolution_par_decennie avec une zone inexistante
    2. Vérifier que le résultat est un dictionnaire vide
    """
    pass  # à remplacer par le code du candidat
 
 
def test_une_seule_decennie():
    """
    Test 2: Tester une zone avec données sur une seule décennie
 
    À compléter:
    1. Appeler evolution_par_decennie avec la zone appropriée
    2. Vérifier que le résultat ne contient qu'une seule décennie (2020)
    3. Vérifier la température moyenne
    """
    pass  # à remplacer par le code du candidat
 
 
def test_plusieurs_decennies():
    """
    Test 3 : Tester une zone avec données sur plusieurs décennies
 
    À compléter:
    1. Appeler evolution_par_decennie avec la zone appropriée
    2. Vérifier que le résultat contient bien les clés 2010 et 2020
    3. Vérifier que les températures moyennes sont cohérentes
    """
    pass  # à remplacer par le code du candidat