Révisions sur la structure de liste en Python

juin 29, 2025k777-9791_30

Exercice 1

Écrire une fonction qui reçoit comme argument une liste de nombres à virgule et recherche lequel est le plus grand et lequel est le plus petit.

La spécification de la fonction est la suivante :

1
2
3
4
5


def minmax(liste: list[float]) -> tuple[float]:
    """
    Retourne un tuple constitué des valeurs minimale
    et maximale de la liste
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


def minmax(liste: list[float]) -> tuple[float]:
    """
    Retourne un tuple constitué des valeurs minimale
    et maximale de la liste
    """
    val_min = liste[0]
    val_max = liste[0]
    for i in range(1, len(liste) - 1):
        if liste[i] > val_max:
            val_max = liste[i]
        if liste[i] < val_min:
            val_min = liste[i]
    return val_min, val_max

Exercice 2

Écrire une fonction qui reçoit comme argument une liste et détermine le nombre d’éléments dans la liste. Ne pas utiliser la fonction len du langage.

La spécification de la fonction est la suivante :

1
2
3
4
5


def longueur(liste: list[float]) -> int:
    """
    Retourne le nombre d'éléments dans la
    liste
    """

Solution

1
2
3
4
5
6
7
8
9


def longueur(liste: list[float]) -> int:
    """
    Retourne le nombre d'éléments dans la
    liste
    """
    longueur = 0
    for i in range(len(liste)):
        longueur += 1
    return longueur

Exercice 3

Écrire une fonction qui simule le tirage du Loto. Pour rappel, il s’agit de tirer aléatoirement 6 entiers compris entre 1 et 49.

Remarque. Un numéro ne peut apparaître qu’une seule fois. Il est donc nécessaire de stocker le résultat de chaque tirage dans une liste et de vérifier s’il est présent ou pas.

La spécification de la fonction est la suivante :

1
2
3
4
5


def loto() -> list[int]:
    """
    Simule le tirage du Loto. retourne une liste de 6 entiers compris
    entre 1 et 49.
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12


def loto() -> list[int]:
    """
    Simule le tirage du Loto. retourne une liste de 6 entiers compris
    entre 1 et 49.
    """
    tirages = []
    nbre_valeurs = 6
    while len(tirages) <= nbre_valeurs:
        tirage = randint(1, 49)
        if tirage not in tirages:
            tirages.append(tirage)
    return tirages

Exercice 4

Écrire une fonction qui reçoit une liste de notes comprises entre 0 et 20 comme argument et retourne la moyenne de ces notes et le pourcentage de ces notes comprises dans les intervalles : [0, moy – 3], [moy – 3, moy + 3] et [moy + 3, 20] où moy est la valeur moyenne des notes.

La signature de la fonction est :

1
2
3
4
5
6
7


def statistiques(notes: List[float]) -> Tuple[float]:
    """
    Détermine les statistiques des notes reçues 
    en argument : moyenne et notes comprises dans
    les intervalles [0, moy - 3[, [moy - 3, moy + 3[, 
    [moy + 3, 20]
    """

Cette fonction doit utiliser les deux fonctions de signature :

1
2
3
4
5


def moyenne(liste_notes: List[float]) -> float:
    """
    Détermine la moyenne des notes reçues en 
    argument dans la liste passée en argument.
    """

1
2
3
4
5


def nombre_dans_intervalle(liste: List[float], valeur_min: float, valeur_max: float) -> float:
    """
    Détermine le nombre de valeurs de liste 
    comprises dans l'intervalle [val_min, val_max[.
    """

Exercice 5

Écrire une fonction qui, partir de deux points de l’espace à trois dimensions, calcule la distance euclidienne entre ces deux points. Remarque. Les coordonnées d’un point sont stockées dans un tuple.

La spécification de la fonction est :

1
2
3
4
5
6
7


def distance(pt1: tuple[float], pt2: tuple[float]) -> float:
    """
    Détermine la distance entre les points pt1 et 
    pt2.
    ERREUR si les dimensions des tuples ne 
    correspondent pas.
    """

Exercice 6

Reprendre l’exercice précédent et considérer que les points appartiennent à un espace de dimension N (N étant potentiellement grand).

La spécification de la fonction est :

1
2
3
4
5
6
7


def distanceN(pt1: Tuple[float], pt2: Tuple[float]) -> float:
    """
    Détermine la distance entre les points pt1 et 
    pt2.
    ERREUR si les dimensions des tuples ne 
    correspondent pas.
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


from math import sqrt

def distanceN(pt1: tuple[float], pt2: tuple[float]) -> float:
    """
    Détermine la distance entre les points pt1 et
    pt2.

    ERREUR si les dimensions des tuples ne
    correspondent pas.
    """
    if len(pt1) != len(pt2):
        raise Exception("Les dimensions ne correspondent pas !")

    carre_distance: float = 0
    for i in range(len(pt1)):
        carre_distance += (pt2[i] - pt1[i])**2

    return sqrt(carre_distance)

Exercice 7

Écrire une fonction qui retourne une la table de multiplication de tous les nombres entiers compris entre 0 et n sous forme d’une liste de listes.

La spécification de la fonction est :

1
2
3
4
5
6
7
8


def table_multiplication(n: int) -> list[list[int]]:
    """
    Détermine la table de multiplication de tous les 
    entiers compris entre 1 et n.
    
    >>> table_multiplication(4)
    [[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16



def table_multiplication(n: int) -> list[list[int]]:
    """
    Détermine la table de multiplication de tous les 
    entiers compris entre 1 et n.

    >>> table_multiplication(4)
    [[1, 2, 3, 4], [2, 4, 6, 8], [3, 6, 9, 12], [4, 8, 12, 16]]
    """
    table = []
    for i in range(1, n + 1):
        ligne = []
        for j in range(1, n + 1):
            ligne.append(i * j)
        table.append(ligne)
    return table

Révisions sur les structures de boucle en Python

juin 29, 2025k777-9791_30

Exercice 1

Écrire et exécuter une fonction qui retourne une chaîne de caractères formée par une suite des 10 premiers termes de la table de multiplication d’un entier a passé en argument. La spécification de la fonction est :

1
2
3
4
5
6
7
8


def multiplication(a: int) -> str:
    """
    Retourne une chaîne de caractères formées des 10 premiers
    nombres de la table de multiplication de a.
    
    >>> multiplication(7)
    '7 14 21 28 35 42 49 56 63 70 '
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22


def multiplication(a: int) -> str:
    """
    Retourne une chaîne de caractères formées des 10 premiers
    nombres de la table de multiplication de a.

    >>> multiplication(7)
    '7 14 21 28 35 42 49 56 63 70 '
    """
    chaine_retour = ""
    nbre_tours_boucle = 10

    # for i in range(1, nbre_tours_boucle + 1):
    #    chaine_retour += str(a * i)
    #    chaine_retour += " "

    i = 1
    while i <= nbre_tours_boucle:
        chaine_retour += str(a * i)
        chaine_retour += " "
        i += 1

    return chaine_retour

Exercice 2

Écrire et exécuter une fonction qui retourne une chaîne de caractères formée par une suite des 10 premiers termes de la table de multiplication d’un entier a passé en argument en signalant au passage (à l’aide d’un astérisque) ceux qui sont des multiples de 3. La spécification de la fonction est :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11


def multiplication_multiple_trois(a: int) -> str:
    """
    Retourne une chaîne de caractères formées des 10 premiers
    nombres de la table de multiplication de a en signalant au
    passage ceux qui sont des multiples de 3.
    
    >>> multiplication_multiple_trois(2)
    '2 4 6* 8 10 12* 14 16 18* 20 '
    >>> multiplication_multiple_trois(7)
    '7 14 21* 28 35 42* 49 56 63* 70 '
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24


def multiplication_multiple_trois(a: int) -> str:
    """
    Retourne une chaîne de caractères formées des 10 premiers
    nombres de la table de multiplication de a en signalant au
    passage ceux qui sont des multiples de 3.

    >>> multiplication_multiple_trois(2)
    '2 4 6* 8 10 12* 14 16 18* 20 '
    >>> multiplication_multiple_trois(7)
    '7 14 21* 28 35 42* 49 56 63* 70 '
    """
    chaine_retour = ""
    nbre_tours_boucle = 10

    for i in range(1, nbre_tours_boucle + 1):
        resultat_multiplication = a * i
        chaine_retour += str(resultat_multiplication)

        if resultat_multiplication % 3 == 0:
            chaine_retour += "*"

        chaine_retour += " "

    return chaine_retour

Exercice 3

Écrire et exécuter une fonction qui calcule les 50 premiers termes de la table de multiplication d’un nombre a passé en argument mais qui retourne une chaîne de caractères formée seulement par ceux qui sont des multiples de 7. La spécification de la fonction est :

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def multiplication_multiple_sept(a: int) -> str:
    """
    Calcule les 50 premiers termes de la table de a mais retourne
    une chaîne de caractères contenant uniquement les multiples de 7.
    
    >>> multiplication_multiple_sept(2)
    '14 28 42 56 70 84 98 '
    >>> multiplication_multiple_sept(9)
    '63 126 189 252 315 378 441 '
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19


def multiplication_multiple_sept(a: int) -> str:
    """
    Calcule les 50 premiers termes de la table de a mais retourne
    une chaîne de caractères contenant uniquement les multiples de 7.

    >>> multiplication_multiple_sept(2)
    '14 28 42 56 70 84 98 '
    >>> multiplication_multiple_sept(9)
    '63 126 189 252 315 378 441 '
    """
    chaine_retour = ""
    nbre_tours_boucle = 50

    for i in range(1, nbre_tours_boucle + 1):
        resultat_multiplication = a * i
        if resultat_multiplication % 7 == 0:
            chaine_retour += str(resultat_multiplication)
            chaine_retour += " "
    return chaine_retour

Exercice 4

Écrire et exécuter une fonction qui calcule et retourne une chaîne de caractères formée de la liste des diviseurs du nombre passé en argument. La spécification de la fonction est :

1
2
3
4
5
6
7
8


def diviseurs(a: int) -> str:
    """
    Retourne une chaîne de caractères formée de la liste des diviseurs
    de a.
    
    >>> diviseurs(18)
    '18 9 6 3 2 1 '
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23


def diviseurs(a: int) -> str:
    """
    Retourne une chaîne de caractères formée de la liste des diviseurs
    de a.

    >>> diviseurs(18)
    '18 9 6 3 2 1 '
    """
    chaine_retour = ""
    diviseur_possible = a

    # while diviseur_possible >= 1:
    #    if a % diviseur_possible == 0:
    #        chaine_retour += str(diviseur_possible)
    #        chaine_retour += " "
    #    diviseur_possible -= 1

    for i in range(a, 0, -1):  # i est diviseur possible
        if a % i == 0:
            chaine_retour += str(i)
            chaine_retour += " "

    return chaine_retour

Exercice 5

Écrire une fonction qui retourne une chaîne de caractère formée des 10 premiers termes de la table de multiplication de 1 à 10. Le caractère de passage à la ligne \n doit être utilisé afin de séparer les différentes tables (de 2, de 3, etc.).

Remarque : Utiliser deux boucles imbriquées.

La spécification de la fonction est :

1
2
3
4


def table_multiplication() -> str:
    """
    Retourne la table de multiplication des nombres de 1 à 10.
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14


def table_multiplication() -> str:
    """
    Retourne la table de multiplication des nombres de 1 à 10.
    """
    chaine_retour = ""
    nbre_termes = 10

    for i in range(1, nbre_termes + 1):
        for j in range(1, nbre_termes + 1):
            chaine_retour += str(i * j)
            chaine_retour += " "
        chaine_retour += "\n"

    return chaine_retour

Remarque : Afin de visualiser le résultat sous forme d’un tableau, utiliser l’instruction suivante, dans la console, pour tester la fonction :

1

>>> print(table_multiplication())

Exercice 6

Écrire et exécuter une fonction qui demande 10 nombres à l’utilisateur et qui détermine lequel est le plus grand et lequel est le plus petit. Les deux résultats sont retournés au sein d’une unique chaîne de caractères.

Remarque : la fonction qui permet de récupérer du texte entré au clavier est input :

1

valeur = float(input("Entrez votre valeur : "))

La specification de la fonction est :

1
2
3
4
5


def plus_grand_plus_petit() -> str:
    """
    Demande à l'utilisateur d'entrer 10 valeurs et retourne une
    chaîne de caractères formée des deux valeurs max et min.
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


def plus_grand_plus_petit() -> str:
    """
    Demande à l'utilisateur d'entrer 10 valeurs et retourne une
    chaîne de caractères formée des deux valeurs max et min.
    """
    nbre_tours = 10
    valeur_max = float('-inf')  # Plus petite valeur possible
    valeur_min = float('inf')   # Plus grande valeur possible

    for i in range(1, nbre_tours + 1):
        valeur = float(input(f"Entrez la valeur {i} : "))
        if valeur > valeur_max:
            valeur_max = valeur
        if valeur < valeur_min:
            valeur_min = valeur

    return f"Min : {valeur_min}, Max : {valeur_max}"

Exercice 7

Reprendre l’exercice précédent mais en faisant en sorte que le nombre de valeurs demandées à l’utilisateur soit passé en argument à la fonction.

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16


def plus_grand_plus_petit(nbre_tours: int) -> str:
    """
    Demande à l'utilisateur d'entrer 10 valeurs et retourne une
    chaîne de caractères formée des deux valeurs max et min.
    """
    valeur_max = float('-inf')  # Plus petite valeur possible
    valeur_min = float('inf')   # Plus grande valeur possible

    for i in range(1, nbre_tours + 1):
        valeur = float(input(f"Entrez la valeur {i} : "))
        if valeur > valeur_max:
            valeur_max = valeur
        if valeur < valeur_min:
            valeur_min = valeur

    return f"Min : {valeur_min}, Max : {valeur_max}"

Exercice 8

Écrire et exécuter une fonction qui demande à l’utilisateur d’entrer 10 notes et qui retourne la moyenne de ces notes. La spécification de la fonction est :

1
2
3
4


def moyenne() -> float:
    """
    Demande 10 notes à l'utilisateur et retourne la moyenne.
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


def moyenne() -> float:
    """
    Demande 10 notes à l'utilisateur et retourne la moyenne.
    """
    nbre_notes = 10
    total_notes = 0
    for i in range(nbre_notes):
        note = float(input(f"Entrez la note {i + 1} : "))
        total_notes += note
    return total_notes / nbre_notes

Exercice 9

Modifier le programme précédent de façon à ce que le nombre de notes à prendre en compte soit passé en argument de la fonction.

Solution

1
2
3
4
5
6
7
8
9


def moyenne(nbre_notes: int) -> float:
    """
    Demande 10 notes à l'utilisateur et retourne la moyenne.
    """
    total_notes = 0
    for i in range(nbre_notes):
        note = float(input(f"Entrez la note {i + 1} : "))
        total_notes += note
    return total_notes / nbre_notes

Exercice 10

Modifier le programme précédent de façon à ce que l’utilisateur n’ait pas à indiquer le nombre de notes qu’il souhaite saisir. Une note négative terminer la saisie.

Remarque : la fonction doit afficher le nombre de notes saisies.

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17


def moyenne_auto() -> tuple[int, float]:
   """
   Demande des notes à l'utilisateur tant que ce dernier
   ne rentre pas une note négative.
   Retourne le nombre de notes et la moyenne.
   """
   nbre_notes = 0
   total_notes = 0
   stop = False
   while not stop:
       note = float(input(f"Entrez la note {nbre_notes + 1} : "))
       if note < 0:
           stop = True
       else:
           total_notes += note
           nbre_notes += 1
   return (nbre_notes, total_notes / nbre_notes)

Exercice 11

Écrire et exécuter une fonction qui simule un tirage du Loto.
La spécification de la fonction est

1
2
3
4
5


def loto_naif() -> str:
    """
    Retourne 6 entiers sélectionnés aléatoirement dans l'intervalle
    [1, 49].
    """

Remarque. Normalement, lorsqu’un numéro est tiré, il ne peut pas apparaître à nouveau. On acceptera cependant qu’un même numéro puisse apparaitre plusieurs fois puisqu’on ne connaît pas encore de structure de contrôle qui permet de facilement « stocker » plusieurs valeurs.

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


from random import randint

def loto_naif() -> str:
    """
    Retourne 6 entiers sélectionnés aléatoirement dans l'intervalle
    [1, 49].
    """
    nbre_valeurs = 6
    rep = ""
    for i in range(nbre_valeurs):
        valeur = randint(1, 49)
        rep += str(valeur) + " "
    return rep

Exercice 12

Écrire et exécuter une fonction qui tire au hasard un nombre entier compris entre 1 et 50 et demande à l’utilisateur de le deviner.

Cette fonction doit indiquer à l’utilisateur si sa tentative est trop grande ou trop petite et quitter dès l’instant où il a deviné le nombre en indiquant le nombre de tentatives.

Remarque. La fonction ne doit rien retourner, elle doit utiliser la fonction print pour afficher à l’écran les informations. Sa spécification est

1
2
3
4
5


def devine() -> None:
    """
    Déterminer aléatoirement un nombre compris en 1 et 50 et demande à l'utilisateur de le deviner.
    La fonction affiche des messages qui aident l'utilisateur dans recherche et quitte dès que cette dernière est fructueuse.
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


def devine() -> None:
    """
    Déterminer aléatoirement un nombre compris en 1 et 50 et demande à l'utilisateur de le deviner.
    La fonction affiche des messages qui aident l'utilisateur dans recherche et quitte dès que cette dernière est fructueuse.
    """
    nbre_a_deviner = randint(1, 50)
    nbre_tentatives = 0
    trouve = False
    while not trouve:
        proposition = int(input("Entrez votre proposition : "))
        nbre_tentatives += 1
        if proposition == nbre_a_deviner:
            trouve = True
        elif proposition > nbre_a_deviner:
            print("La proposition est trop grande !")
        else:
            print("La proposition est trop petite !")
    print(f"Nombre de tentatives : {nbre_tentatives}")

Exercice 13

Écrire et exécuter une fonction qui affiche l’alphabet à l’endroit si elle reçoit l’argument "croissant" ou à l’envers si elle reçoit l’argument "decroissant".

Remarque. On peut obtenir le code décimal d’un caractère à l’aide de la fonction ord. À l’opposé, le caractère correspondant à un entier naturel dans la table ASCII est obtenu (si possible) à l’aide de la fonction chr.

La spécification de la fonction est

1
2
3
4
5
6
7
8


def alphabet(sens: str) -> str:
    """
    Retourne les lettres de l'alphabet en fonction de la chaîne de caractères
    passée en argument.
    Les valeurs possibles pour cet argument sont 'croissant' ou 'decroissant'.

    Code ascii [97; 122]
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


def alphabet(sens: str) -> str:
    """
    Retourne les lettres de l'alphabet en fonction de la chaîne de caractères
    passée en argument.
    Les valeurs possibles pour cet argument sont 'croissant' ou 'decroissant'.

    Code ascii [97; 122]
    """
    if sens == "croissant":
        debut_code, fin_code, increment, pas = 97, 122, 1, 1
    else:
        debut_code, fin_code, increment, pas = 122, 97, -1, -1

    rep = ""
    for i in range(debut_code, fin_code + increment, pas):
        rep += chr(i)

    return rep

Exercice 14

Écrire et exécuter une fonction qui détermine les n premiers termes de la « suite de Fibonacci » définie par :

$\begin{aligned} u_{1} & = 1 \\ u_{2} & = 1 \\ u_{n} & = u_{(n - 1)} + u_{(n - 2)} pour n > 2 \end{aligned}$

Cette fonction doit recevoir en argument la valeur de $n$ et retourner la suite de nombres sous forme de chaîne de caractères. Spécification de la fonction :

1
2
3
4


def fibo(n: int) -> str:
    """
    Retourne les n premiers termes de la suite de Fibonacci.
    """

Solution

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13


def fibo(n: int) -> str:
    """
    Retourne les n premiers termes de la suite de Fibonacci.
    """
    rep = "0 1 "
    u = 0
    v = 1
    for i in range(2, n):
        z = u + v
        rep += str(z) + " "
        u = v
        v = z
    return rep

Héron d’Alexandrie

juin 29, 2025juin 29, 2025k777-9791_30

Héron d’Alexandrie est un ingénieur, un mécanicien et un mathématicien grec du premier siècle après J.-C.

On ne sait pas grand chose de la vie d’Héron, si ce n’est qu’il était originaire d’Alexandrie ; les historiens se sont même longtemps divisés sur l’époque où il a vécu. Leurs estimations allaient du 1^er siècle avant J.-C. au 3^ème siècle de notre ère. Aujourd’hui, la querelle est éteinte : il est clairement établi que Héron est postérieur à Vitruve mort en $- 20$ , et contemporain de Pline l’Ancien (23 – 79), en étant actif autour de l’an 62. Il a donc bien vécu au 1^er siècle après J.-C. et sans doute au début du 2^ème siècle, donc sous l’Empire romain, mais dans l’Alexandrie grecque.

On attribue à Héron d’Alexandrie plusieurs formules mathématiques et une méthode efficace d’extraction de racine carrée, c’est-à-dire de résolution de l’équation $x^{2} = a$ , avec $a$ positif :

Choisir une première valeur raisonnable que l’on note $G$ .
Améliorer cette valeur en calculant la moyenne des valeurs $G$ et $x / G$ .
Vérifier si cette nouvelle valeur convient.
Reprendre l’étape 2 tant que la valeur calculée n’est pas satisfaisante.

L’objectif de cette activité est de mettre en œuvre cette méthode en Python.

Travail à réaliser

Le fichier réponse devra se terminer par les instructions afin de pouvoir y placer les jeux de tests pour les différentes fonctions (on découvrira la signification de cette instruction dans quelques jours).

1

if __name__ == "__main__":

Qu’appelle-t-on la documentation d’une fonction ? La spécification d’une fonction ?

Toute fonction doit être accompagnée de sa spécification !

Définir la fonction moyenne dont la spécification est

1
2
3
4


def moyenne(a: float, b: float) -> float: 
    """ Calcule et retourne la moyenne des deux nombres a et b 
    passés en argument.
    """

Ajouter le jeu de test suivant à la fin du fichier :

1
2


assert moyenne(12, 16) == 14
assert moyenne(0, 8) == 4

Réponse

1
2
3
4
5
6


def moyenne(a: float, b: float) -> float:
    """
    Calcule et retourne la moyenne des deux nombres a et b
    passés en argument.
    """
    return (a + b) / 2

Définir la fonction valeur_absolue dont la spécification est :

1
2
3
4


def valeur_absolue(x: float) -> float: 
    """ 
    Calcule et retourne la valeur absolue du nombre x passé en argument.
    """

Remarque.: Il est interdit d’utiliser la fonction abs intégrée à Python.

Ajouter le jeu de test suivant à la fin du fichier :

1
2
3


assert valeur_absolue(3) == 3
assert valeur_absolue(0) == 0
assert valeur_absolue(-3) == 3

Réponse

1
2
3
4
5
6
7
8
9


def valeur_absolue(x: float) -> float:
    """
    Calcule et retourne la valeur absolue du nombre x positif
    passé en argument.
    """
    if x >= 0 :
        return x
    else:
        return -x

Définir la fonction puissance dont la spécification est :

1
2
3
4


def puissance(x: float, n: int) -> float: 
    """ calcule et retourne le résultat de x à la puissance entière n :
    x^n = x . x . x . … . x (n fois)
    """

Remarque.: Il est interdit d’utiliser l’opérateur ** intégré à Python ou la fonction pow du module math.

Ajouter le jeu de test suivant à la fin du fichier :

1
2
3


assert puissance(2, 8) == 256
assert puissance(0, 2) == 0
assert puissance(3, 0) == 1

Réponse

1
2
3
4
5
6
7
8
9


def puissance(x: float, n: int) -> float:
    """
    calcule et retourne le résultat de x à la puissance entière n :
    x^n = x . x . x . ... . x (n fois)
    """
    res = 1
    for i in range(1, n + 1):
        res *= x
    return res

Définir la fonction amelioration_essai dont la spécification est :

1
2
3
4


def amelioration_essai(essai: float, x: float) -> float: 
    """ Calcule et retourne la moyenne des nombres essai (strictement positif) 
    et x/essai.
    """

Remarque.: Cette fonction doit utiliser la fonction moyenne définie plus haut.

Ajouter le jeu de test suivant à la fin du fichier :

1
2


assert amelioration_essai(1, 2) == 1.5
assert amelioration_essai(2, 1) == 1.25

Réponse

1
2
3
4
5


def amelioration_essai(essai: float, x: float) -> float:
    """
    Calcule et retourne la moyenne des nombres essai (strictement positif) et x/essai.
    """
    return moyenne(essai, x/essai)

Définir le prédicat est_suffisamment_bon dont la spécification est :

1
2
3
4
5
6


def est_suffisamment_bon(essai: float, x: float) -> bool: 
    """ 
    Retourne True si la valeur absolue de la différence du carré du nombre essai 
    et du nombre x est inférieure à une tolérance donnée (prendre 0.001).
    Retourne False sinon.
    """

Remarque.: Cette fonction doit utiliser les fonctions valeur_absolue et puissance définies ci-dessus.

Ajouter le jeu de test suivant à la fin du fichier :

1
2
3


assert est_suffisamment_bon(1.9, 4) == False
assert est_suffisamment_bon(1.999, 4) == False
assert est_suffisamment_bon(1.9999, 4) == True

Réponse

1
2
3
4
5
6
7
8
9


def est_suffisamment_bon(essai: float, x: float) -> bool:
    """
    Retourne True si la valeur absolue de la différence du carré du nombre essai
    et du nombre x est inférieure à une tolérance donnée (prendre 0.001).
    Retourne False sinon.
    """
    tolerance = 0.001

    return valeur_absolue(puissance(essai, 2) - x) < tolerance

Définir la fonction test qui implémente l’algorithme de Héron d’Alexandrie. La spécification de la fonction est :

1
2
3
4
5


def test(essai: float, x: float) -> float: 
    """ 
    Retourne la racine carrée du nombre x. Le calcul est effectué grâce à un
    raisonnement itératif depuis une première valeur strictement positive notée essai.
    """

Remarque.: Cette fonction doit utiliser les fonctions est_suffisamment_bon et amelioration_essai.

Ajouter le jeu de test suivant à la fin du fichier :

1
2
3


assert test(2, 4) == 2
assert test(1, 4) == 2.0000000929222947
assert test(7, 4) == 2.0000000271231317

Réponse

1
2
3
4
5
6
7
8
9


def test(essai: float, x: float) -> float:
    """
    Retourne la racine carrée du nombre x. Le calcul est effectué grâce à un
    raisonnement itératif depuis une première valeur strictement positive notée
    essai.
    """
    while not est_suffisamment_bon(essai, x):
        essai = amelioration_essai(essai, x)
    return essai

Définir la fonction racine_carree dont la spécification est :

1
2
3
4
5


def racine_carree(x: float) -> float: 
    """ 
    Retourne le résultat de l'appel de la fonction test avec la valeur 1 
    pour l'argument essai.
    """

Ajouter le jeu de test suivant à la fin du fichier :

1
2
3


assert racine_carree(4) == 2.0000000929222947
assert racine_carree(9) == 3.00009155413138
assert racine_carree(16) == 4.000000636692939

Réponse

1
2
3
4
5
6


def racine_carree(x: float) -> float:
    """
    Retourne le résultat de l'appel de la fonction test avec la valeur 1 pour l'argument essai.
    """

    return test(x, 1)

Définir la fonction main qui affiche à l’écran la liste des racines carrées de tous les nombres pairs compris dans l’intervalle $[1; 100]$ .

Ajouter l’appel de la fonction main à la fin du fichier.

Réponse

1
2


def main():
    return [racine_carree(i) for i in range(1, 100) if i % 2 == 0]

Terminale NSI 2025-26

juin 29, 2025juillet 10, 2025k777-9791_30

chapitre 1 : révisions

chapitre 2 : programmation récursive

chapitre 3 : structures de données

cours et exercices

chapitre 4 : programmation fonctionnelle

sources

Maths93

Sujets du Bac 2025 de NSI épreuve pratique Thème exercice 1 du Bac 2025 de NSI épreuve pratique Thème exercice 2 du Bac 2025 de NSI épreuve pratique Code Corrections du Bac 2025 de NSI épreuve pratique

Sujet N°01 Arbre (Tle) : graphe orienté représenté sous forme de listes d’adjacence. Calcul des voisins entrants dans un graphe orienté représenté par des listes d’adjacence. Listes 1re : Génération de la suite du « look-and-say » (1, 11, 21, 1211, 111221…). Code Correction NSI 2025 sujet 1 (sujet 48 de 2024)

Sujet N°02 Listes (max.) 1re : Valeur et indice du maximum (1re) Listes 1re : Ordre des gènes sur un chromosome (1re) Code Correction NSI 2025 sujet 2

Sujet N°03 Suite (Maths) 1re: Calcul des termes de la suite de Fibonacci (1re) Listes 1re : Liste des élèves ayant obtenu la note maximale (1re) Code Correction NSI 2025 sujet 3

Sujet N°04 Bases (Maths) 1re: Conversion du décimal vers le binaire (1re) Tri Bulles (Tle) : Tri à bulles Code Correction NSI 2025 sujet 4

Sujet N°05 Chaînes caractères 1re : Ecriture d’une chaine de caractères à l’envers (1re) Listes 1re : Crible d’Erasthotène (1re) Code Correction NSI 2025 sujet 5

Sujet N°06 Listes 1re : Calcul de puissances avec multiplication successives (1re) Dictionaires 1re : Codage d’un mot (1re) Code Correction NSI 2025 sujet 6

Sujet N°07 Dictionaires 1re : Nombre d’occurrences des caractères (dictionnaire) Tri et fusion 1re/Tle : Fusion de deux listes déjà triées Code Correction NSI 2025 sujet 7

Sujet N°08 Listes 1re : Maximum des éléments d’un tableau (1re POO, Pile (Tle) : Parenthésage correct Code Correction NSI 2025 sujet 8

Sujet N°09 Multiplications avec uniquement additions et soustractions (1re) Dichotomie recherche 1re : Recherche par dichotomique (1re) Code Correction NSI 2025 sujet 9

Sujet N°10 Dichotomie 1re : Recherche dichotomique Chaînes caractères 1re : Code de César (1re) Code Correction NSI 2025 sujet 10

Sujet N°11 Arbre binaire, Parcours Largeur (Tle) : On souhaite écrire une fonction parcours_largeur qui prend en paramètre un arbre binaire et qui renvoie la liste des étiquettes des nœuds de l’arbre parcourus en largeur. Programmation Dynamique (Tle) : On considère un tableau de nombre entiers, positifs ou négatifs, et on souhaite déterminer la plus grande somme possible de ses éléments consécutifs. Code Correction NSI 2025 sujet 11

Sujet N°12 Tri et fusion 1re/Tle : Fusion de deux listes déjà triées Recursif et dictionnaires (Tle) : Conversion numération romaine Code Correction NSI 2025 sujet 12

Sujet N°13 Listes 1re : Recherche indice de la première occurrence dans un tableau (1re Listes 1re : Insertion dans une liste triée (1re *) Code Correction NSI 2025 sujet 13

Sujet N°14 Simulation de lancers de dés. (1re) Listes 1re : Représentation d’une image par une liste de listes Code Correction NSI 2025 sujet 14

Sujet N°15 Multiplications avec uniquement additions et soustractions (1re) Dichotomie, recursivité (Tle) : Recherche par dichotomique récursive Code Correction NSI 2025 sujet 15

Sujet N°16 Listes 1re : Moyenne pondérée (1re) Listes 1re : Liste de Listes – Triangle de Pascal (1re*) Code Correction NSI 2025 sujet 16

Sujet N°17 Recursif, Arbre (Tle) : Écrire une fonction récursive taille prenant en paramètre un arbre a et qui renvoie la taille de l’arbre que cette instance implémente. Écrire de même une fonction récursive hauteur prenant en paramètre un arbre a et qui renvoie la hauteur de l’arbre que cette instance implémente. Listes 1re : Insertion d’un élément dans une liste à une position donnée (1re) Code Correction NSI 2025 sujet 17

Sujet N°18 Listes 1re : Moyenne des éléments d’un tableau (1re) Dichotomie 1re : Recherche par dichotomie Code Correction NSI 2025 sujet 18

Sujet N°19 Listes 1re : Première occurence du minimum (1re) Listes 1re : Separation des 0 et des 1 dans un tableau (1re) Code Correction NSI 2025 sujet 19

Sujet N°20 Dictionaires 1re : Minimum et maximum des éléments d’un tableau (1re) POO (Tle) : Classe représentant des cartes (POO) Code Correction NSI 2025 sujet 20

Sujet N°21 Listes 1re : Liste des indices du maximum (1re) Piles (Tle) : Pile des éléments positifs Code Correction NSI 2025 sujet 21 Sujet N°22 Listes 1re : Indice de la dernière occurence (1re) POO (Tle) : Classe des adresse Ip (POO) Code Correction NSI 2025 sujet 22

Sujet N°23 Tri 1re : On veut trier par ordre croissant les notes d’une évaluation qui sont des nombres entiers compris entre 0 et 10 (inclus). Recursif (Tle) :vL’objectif de cet exercice est d’écrire deux fonctions récursives dec_to_bin et bin_to_dec assurant respectivement la conversion de l’écriture décimale d’un nombre entier vers son écriture en binaire et, réciproquement, la conversion de l’écriture en binaire d’un nombre vers son écriture décimale Code Correction NSI 2025 sujet 23

Sujet N°24 Dictionaires 1re : Écrire une fonction enumere qui prend en paramètre un tableau tab(typelist) et renvoie un dictionnaire d dont les clés sont les éléments de tab avec pour valeur associée la liste des indices de l’élément dans le tableau tab. Arbre Binaire, parcours profondeur (Tle) : La fonction récursive parcours renvoie la liste des étiquettes des nœuds de l’arbre implémenté par l’instance arbre dans l’ordre du parcours en profondeur infixe à partir d’une liste vide passée en argument. Code Correction NSI 2025 sujet 24 Compléter le code de la fonction insere, qui prend en argument un arbre binaire de recherche arbre représenté ainsi et une étiquette cle, non présente dans l’arbre, et qui renvoie une nouvelle feuille d’étiquette cle s’il est vide ; • renvoie l’arbre après l’avoir modifié en insérant cle sinon ; • garantit que l’arbre ainsi complété soit encore un arbre binaire de recherche. …

Sujet N°25 Listes 1re : Minimum d’une liste de température (1re) Chaînes caractères 1re : Palindromes (1re) Code Correction NSI 2025 sujet 25

Sujet N°26 Dictionaires 1re : Fusion de deux dictionnaires Simulation d’un jeu de dés (1re) Code Correction NSI 2025 sujet 26

Sujet N°27 Tri 1re : Vérification si une liste est triée ou non (1re) Dictionaires 1re : Comptabilisation de votes (1re) Code Correction NSI 2025 sujet 27

Sujet N°28 Listes 1re : Présence de doublons dans une liste triée (1re) Listes 1re : Création de grille au démineur (1re *) (*) Code Correction NSI 2025 sujet 28

Sujet N°29 Dictionaires 1re : Traitement de données en table (animaux et enclos) Recursif (Tle) : Recherche récursive dans un tableau Code Correction NSI 2025 sujet 29

Sujet N°30 Listes 1re : Codage par différence (1re) Recursif, POO, arbre (Tle) : Expression arithmétique représentée par un arbre binaire Code Correction NSI 2025 sujet 30 Le codage par différence (delta encoding en anglais) permet de compresser un tableau de données en indiquant pour chaque donnée, sa différence avec la précédente (plutôt que la donnée elle-même).

Sujet N°31 Recherche Morif dans Texte (Tle) : Écrire une fonction recherche_motif qui prend en paramètre une chaîne de caractères motif non vide et une chaîne de caractères texte et qui renvoie la liste des positions de motif dans texte. Graphe, Matrice adj., parcours profondeur (Tle) : On souhaite déterminer les sommets accessibles depuis un sommet donné dans le graphe. Pour cela, on va procéder à un parcours en profondeur du graphe. Code Correction NSI 2025 sujet 31

Sujet N°32 Listes 1re : Nombre d’occurrences d’un élément dans une liste (1re) (Glouton 1re) : Rendu de monnaie (1re) Code Correction NSI 2025 sujet 32

Sujet N°33 POO, Recursif, arbre (*Tle) : Ajout d’une clé dans un arbre binaire (Glouton 1re) : Compléter la fonction Python empaqueter(liste_masses, c) suivante pour qu’elle renvoie le nombre de boîtes de capacité c nécessaires pour empaqueter un ensemble d’objets dont les masses sont contenues dans la liste liste_masses. (1re) Code Correction NSI 2025 sujet 33 (arbre binaire de recherche, récursivité, programmation objet)

Sujet N°34 Tri 1re : Tri par sélection Jeu du plus ou moins (1re) Co Correction NSI 2025 sujet 34

Sujet N°35 Dictionaires 1re : Maximum des valeurs d’un dictionnaire (1re) POO, Pile (Tle) :Compléter le script de la fonction eval_expression qui reçoit en paramètre une liste python représentant la notation postfixe d’une expression arithmétique et qui renvoie sa valeur associé Code Correction NSI 2025 sujet 35

Sujet N°36 Chaînes caractères 1re : Nombre de mots dans une phrase (1re) POO, Arbre, recursivité (Tle) : Arbre binaire (POO) Code Correction NSI 2025 sujet 36

Sujet N°37 Binaire (1re) : Représentation binaire d’un entier non signé en tant que tableau de booléens (1re). Tri 1re : Tri par insertion Code Correction NSI 2025 sujet 37

Sujet N°38 Listes 1re : Calcul de moyenne (1re) Binaire (1re) : Conversion du décimal vers le binaire (1re) Code Correction NSI 2025 sujet 38

Sujet N°39 Listes 1re : Moyenne des éléments d’une liste (1re) Listes 1re : Trie d’un tableau composé de 0 et de 1 Code Correction NSI 2025 sujet 39

Sujet N°40 Listes 1re : : Liste des indices des éléments inférieures égaux et supérieurs à une valeur (1re) Dictionaires 1re : Calcul de moyenne (dictionnaire) Code Correction NSI 2025 sujet 40

Sujet N°41 Listes et XOR 1re : XOR de 2 listes de bits (1re) POO (Tle) : Carrés semi-magiques (POO) : Compléter la méthode est_semimagique qui renvoie True si le carré est semimagique, False sinon. Code Correction NSI 2025 sujet 41

Sujet N°42 Listes 1re : Nombre d’occurrences d’un élément dans une liste (1re) Binaire (1re) : Conversion du décimal vers le binaire (1re) Code Correction NSI 2025 sujet 42

Sujet N°43 Listes 1re : Liste des couples d’entiers consécutifs (1re) Listes 1re : Codage d’une image (1re) Code Correction NSI 2025 sujet 43

Sujet N°44 Listes 1re : Moyenne pondérée (1re) Listes 1re : Représentation d’une image par une liste de listes (1re *) (*) Code Correction NSI 2025 sujet 44

Sujet N°45 Chaine de caractères 1re : Programmer une fonction qui prend en paramètres deux chaînes de caractères et qui renvoie True si on peut obtenir mot en remplaçant convenablement les caractères ‘*’ … Dictionaires 1re : Compléter la fonction est_cyclique située à la page suivante en respectant la spécification. Code Correction NSI 2025 sujet 45

Sujet N°46 Listes 1re : Nombre d’occurrences d’un élément dans une liste (1re) Glouton 1re : Rendu de monnaie (1re) Code Correction NSI 2025 sujet 46

Sujet N°47 Recursif (Tle) : Taille d’un arbre binaire (récursivité) Tri 1re : Tri par sélection Code Correction NSI 2025 sujet 47

Sujet N°48 Listes 1re : Fonction qui renvoie l’indice de la dernière occurrence de l’élément cherché. Si l’élément n’est pas présent, la fonction renvoie la longueur du tableau. (1re) Listes 1re : Plus courte distance entre un point et une liste de points (1re) Code Correction NSI 2025 sujet 48

Classes de TerminaleNSI – Numérique et Sciences Informatiques

juin 29, 2025k777-9791_30

Le programme de l’enseignement NSI (numérique et sciences informatiques) de terminale s’appuie sur l’universalité de quatre concepts fondamentaux et la variété de leurs interactions : les données, les algorithmes, les langages, les machines, les interfaces.

Cours et TD NSI terminale

Modularité, Mise au point des programmes et Gestion des bugs.
Ces parties du programme se font tout au long du travail régulier sur la programmation en pyhton.

Programmation Orientée Objet : POO
- Diaporama
- Cours et TD NSI : Cours et activités / avec correction à faire sur Capytale /Correction
  Cours, TD sur la notion de classe et de POO avec corrigés des exercices.
  => Fichier source LaTex.
- TP NSI POO : Les fractions
- Projet NSI POO :
  - Un projet très guidé : Un Casse Brique sur Pygame
  - Un projet très peu guidé :Lemmings
  - Travailler en équipe avec github avec Une petite Vidéo
- Un exercice Type BAC, Pile et POO/
- QCM de révision sur la POO : QCM GeNumsi .
Base de donnée
- Théorie sur les bases de données
- Utilisation du SQL en pdf/ Le TP sous Capytale / Correction .
- Le site d’un collégue pour travailler les requètes simples
- Un exercice Type BAC/Le corrigé
- Un autre exercice Type BAC/Le corrigé
- La site de la CNAM pour s’entrainer aux requétes : Films et SQL
- QCM d’Entrainement
La récursivité
- Cours et TD NSI : Cours et activités sur la récursivité à faire sur Capytale
  Cours et exercices sur la notion de fonctions récursives.
- Un TP sur le flocon de Von Koch / Sur Capytale
- Les tours de Hanoi / Sur Capytale
- Un complement si on est plus rapide que les autres
- Un exercice Type BAC, voir Exercice 1 / Le corrigé
- Un exercice Type BAC un peu plus difficile, voir Exercice 2 / Le corrigé
- Un QCM d’entrainement
Un TP sur la gestion des Bugs:Python, Erreur et Exception
Structure de Donnée
- Piles : le TD en pdf /Le TD sur capytale
- Files :Cours et activités html/notebook sur capytale
- Listes et listes chainées : Cours et activité html /notebook sur capytale
- Dictionnaires : Cours et activité basé sur Le cours d’un collégue
  - Création d’une rainbow table sur Capytale
  - Exercice type BAC Centres Etrangers 2021 J1
- QCM d’entrainement: Pile, File, Liste, dictionnaire et activités
- Arbres : Cours et activités
- Arbres Binaires : Cours et activités / Activité sur Capytale
  - Sujet 0a 2023 / Correction
  - Exeercie Sujet Amerique du Nord J1 2022 / Correction
- Le projet : Codage de Huffmann et Compression : html / notebook/Notebook Sur Capytal
QCMs de révision sur les Structure de DonnéeListes, piles, files, dictionnaires Les arbres
Protocoles de routage : Cours et activités/correction
- Algorithme de Dijkstra : Diaporama / Le noteBook sur Capytale
- Entrainement Type BAC
- Rappel sur le modele TCP/IP
- TP filius : Modelisation et Routage
  - Si besoin telecharger le logiciel de simulation reseau : Filius
Notion de Processus
- Le Diaporama du cours
- Entrainement BAC exercice Sujet Polynésie 2023 Exercice 2 / Correction
- TP Processus sur console UNIX si besoin aller réviser les commandes UNIX vues en premiere.
- Exercices / Correction
- Simulation d’ordonnancement
- Un petit QCM de rappel sur bash et linux
Algorithmique
- Rappel sur la dichotomie: Le TP sur Capytale / Cours et activités
- Rappel sur les tris. Cours et activités
- Exercices sur les tris et Méthode « diviser pour régner » :
  - Notebook sur Capytale
- Un Projet sur capytale Points raprochés
- Un autre Projet sur capytale L’algorithme de Karatsuba
- 2 sujets de Bac :
  - Metropole 2 2022 Exercice 5 / Correction
  - Amerique du sud 2 2022 Exercice 4/ Correction
Composants intégrés d’un système sur puce.
- presentation sur Capytale /Cours et activités Format Notebook
- Exercice type Bac Polynésie 2021 : Au coeur des machines / Corrrection
Histoire de l’informatique
- Une histoire de l’informatique.
- http://www.frisechronos.fr/DojoMain.htm
  Outil pour réaliser une frise
Stucture de Donnée (suite)
- Graphes
  - Une chaine Youtube qui aborde les graphes de façon trés complète.
  - Le cours.
  - Représentation d’un graphe sous forme de dictionnaire sous capytale . / Correction
  - Représentation avec la bibliothéque networkx sous capytale.
  - TD de Recherche en largeur
  - TP de recherche dans un graphe / Correction .
  - TP de Génération de labyrinthe à tester / Correction .
  - Devoir type Bac .
  - Coloration d’un graphe .
Machine de Turing, Calculabilité et Décidabilité
- Une vidéo Arte sur la calculabilité: L’ Entscheidungsproblem ou la fin des mathématiques ?
- Le cours
- Le TD sur Capytale / Le TD en pdf
Programmation dynamique.
- Le cours avec l’exemple de la suite de Fibonnacci : Notebook Cours et activités sur capytale
- Un TP autour du rendu de monnaie : TP Notebook sur capytale
- Une analyse complete, le decoupage d’une barre : TP Notebook sur capytale
Projet de Terminale
- Des projets simples mais developable à l’infini
- Projet du lycée de Balagne
- Des jeux simples à realiser
- Des idees tirées du lycée Blaise Pascal
- Une liste de Projet.
- 1ère étape : travail préparatoire et rendu sur Latex à rendre aprés les vacances de février. Vous devez ouvrir un compte overleaf puis vous copierez le template dans un nouveau projet Latex
- 2ème étape : Faire une partie du projet pour en faire une présentation avec un diaporama pour la fin du mois de mars.
- 3ème étape : Finalisez du projet pour en faire une présentation technique vers le moi de mai.
- Projet le lien sur Capytale
Sécurisation des communications.
Le cours : Diaporama
Vidéo de Sciences étonnantes :
- Les codes secrets (8mn10)
- Comment déchiffrer (presque) n’importe quel message codé ? (13mn24)
TP Chiffrement Symétrique : TP Notebook
TP Chiffrement Asymétrique, RSA : TP RSA NoteBook version simplifiée / TP RSA Notebook complet (Avec démonstration)
Quelques énigmes à décrypter. C’est un peu un DS type.
TP sur le masque jetable avec un codage sur 2 chiffres : XOR et masque jetable
Pour aller plus loin, une vidéo de sciences étonnantes et Diffie Helman, Rho Pollard
Pour aller plus loin Le puzzle de Merkle
Pour les plus curieux : Entrainez vous au Hacking éthique sur https://www.root-me.org/
Paradigmes de programmation.
- Les notions de cours
Recherche d’un motif dans un texte : Algorithme de Boyer-Moor-Horspool
- Cours et TD NSI : Cours et activités.
  Cours, TD sur la recherche d’un motif dans un texte de différentes façons. On insistera sur le traitement du motif.
- Extrait de roman à tester : « La Disparition » de G. Perec.
- Des animations avec présentation de la méthode et du traitement du motif :
  - La recherche naîve : pdf / opd.
  - Boyer-Moore-Horspool : pdf / opd.
  - Boyer-Moore : vidéo.
- Proposition de projets
  - Concevoir un code permettant de visualiser les différentes étapes de l’algorithme.
    - Animation sous Python avec Tkinter : https://repl.it/@fduffaud/Boyer-Moore-animation1.
    - Animation sous de la recherche naive, Boyer-Moore une table et multi tables : https://repl.it/@fduffaud/Boyer-Moore-animation2 .
      .
Des notions sur l’Intelligence Artificielle
- Une premiére approche: L’algorithme des k plus proches voisins (KNN)
- Le TP des k plus proches voisins sur Capytale
- Pour aller un peu plus loin, une notion de réseau de neurones / Correction
Traitement d’image
- Rappel niveau premiere Quelques traitement de base
- Pour la terminale Traitement plus complexes sur Capytale
Vers CPGE
- Simulation d’une planète de Pokémons
- Révisions graphes : plus court chemin (A*, Dijkstra) sur Capytale

Evaluations NSI

Evaluations NSI terminale : Des évaluations de NSI terminale avec les corrigés

Compléments NSI

Générateur et utilisation de yield en python

- NSI : Présentation sur Capytal

LaTeX : produire des documents scientifiques

- NSI : LaTex
  Un outil permettant de produire des documents de qualité.
- NSI : Documents Python
  Pour produire des documents intégrants du code Python

Terminale option maths complémentaires (2024)

août 9, 2024mai 11, 2025Julien Kergot

Lors du premier cours merci de remplir le questionnaire suivant.

règles et conseils

pour les problèmes d’emploi du temps, la direction essaye de faire en sorte que les élèves puissent faire deux options mais ça n’a pas été sans générer quelques petits couacs. Actuellement l’heure du vendredi de 16h à 17h a disparu de l’emploi du temps d’une partie des élèves. Certains ont rencontré Mme Durand (une des deux adjointes) et ont déjà réglé le problème, pour les 9 restants (essentiellement en TG6) ça devrait se régler tout seul sauf pour deux qui devront échanger avec moi vendredi à 17h pour voir comment gérer l’heure commune CAV/Maths Comp. Si vendredi ça n’est pas encore réglé, venez en classe à 16h comme initialement prévu et je verrai avec Mme Durand.

Option Mathématiques complémentaires

L’essentiel des documents accessibles sur cette page ont été produits par Pascal Brachet, professeur de mathématiques.

«L’enseignement optionnel de mathématiques complémentaires est destiné prioritairement aux élèves qui, ayant suivi l’enseignement de spécialité de mathématiques en classe de première et ne souhaitant pas poursuivre cet enseignement en classe terminale, ont cependant besoin de compléter leurs connaissances et compétences mathématiques par un enseignement adapté à leur poursuite d’études dans l’enseignement supérieur, en particulier en médecine, économie ou sciences sociales.
Le programme de mathématiques complémentaires s’appuie sur le programme de spécialité de mathématiques de la classe de première qu’il réinvestit et enrichit de nouvelles connaissances et compétences mathématiques… »

1. Lois de probabilités discrètes

Cours : polycopié ( Corrigé des exercices )
Tutoriels de M. Monka
Calculer une probabilité pour une loi binomiale – Tuto TI
Calculer une proba pour une loi bino (formule) – Tuto TI
Etablir la loi de probabilité (loi binomiale) – Tuto TI
exercices bonus ici
devoirs 2024 : surveillé / maison

2. Limites de fonctions

Cours : polycopié ( Corrigé des exercices ) (correction des points méthode)
devoirs 2024 : surveillé / maison (correction)

3. Dérivation, continuité et convexité

Cours : polycopié
- (cours complet de M. Monka Dérivation / continuité / Convexité avec les démonstrations, les points méthode et les liens vers les vidéos )
- Diaporama écran
- Diaporama imprimable
- Fiche résumé du cours
Exercices :
- Fiche principale d’exercices (Corrigés)
- fiche Lycée Saint Charles (hélas non corrigé)

Evaluations:
- Devoir maison ( version originale de sa correction, l’ordre des exercices a été changé)

4. Complément sur la fonction exponentielle – Fonction logarithme népérien

Polycopié du cours utilisé en classe :
partie fonction expo : Diaporama écran / Diaporama imprimable / Fiche résumé du cours
partie logarithme népérien : Diaporama écran / Diaporama imprimable / Fiche résumé du cours
Exercices :
- Fiche expo / Fiche logarithme
- Corrigé des exercices (complément fonction exponentielle) & (fonction logarithme népérien)
devoirs : DM , DS(correction) , DM 2

5. Statistique à deux variables

Cours : polycopié élèves / points méthode
Exercices :
- Fiche d’exercices officielle (Corrigé)
- fiche BTS domotique (exercice/corrigé)
- fiche STR (non corrigée)

6. Primitives et intégration

Cours :
Exercices :
- fiche exercices Primitives corrigés
- Fiche d’exercices Intégrales (Corrigé des exercices )
- Fiches non corrigées : Primitives / Intégrales
- Page interactive Primitives et intégrales avec correction intégrée (anciens programmes)

7. Lois de probabilités continues

8. Complément sur les suites

Cours : polycopié élèves / points méthode
Fiches d’exercices :
- Fiche principale (Corrigé)
- Lycée Saint Charles (corrigé)

9. Équations différentielles

cours (correction + points méthodes)
Exercices :
- Fiche d’exercices
- Corrigé des exercices

1ère Spécialité Mathématiques (2024)

août 9, 2024mai 10, 2025Julien Kergot

Pour réussir sa rentrée en classe de première (cahier de vacances)

Lors du premier cours merci de remplir le questionnaire suivant.

règlement classe

Chapitre 1 : Polynômes du second degré

cours 2024 (pour la version avec les corrections des démonstrations et des points méthode : sur le site de M. Monka : 1 & 2)
correction des exercices de la fiche de cours
(révisions) factorisations et développement (exercices)
(révisions) racines : deuxième partie du cours (2024), correction fiche de cours et d’exercices ,
factorisation à l’américaine (un short de HedAcademy)
(révisions) systèmes d’équations : cours, entrainement, évaluation, activité niveau 1G
devoirs maison (2023) (2024)
contrôle (2023) (2024) (2024 pt2)
fiche méthode , programme python

Chapitre 2 : Suites numériques (généralités)

activité introductive
cours (2024) correction des exercices.
exercices fiche 1 (corrections)
devoir maison 2023 (correction) 2024 (correction intégrée)
interrogation 1 , 2

Chapitre 3 : Dérivation 1/2 (bases)

cours (2024) correction des exercices.
exercices fiche 2 (corrections)
exercices fiche 3 (corrections)
valeurs absolues (exercices corrigés , fiche méthode)
devoir maison, interrogation, devoir surveillé (2023) , devoir surveillé (2025)

Chapitre 4 : indépendances et probabilités conditionnelles.

cours (2024) correction des exercices.
exercices fiche 1 (corrections)
exercices fiche 2 (corrections)
exercices pages d’exercices corrigés
crossOver suites/probabilités
devoir surveillé (1ère version / 2ème version) , devoir surveillé (2025)

Chapitre 5 : Dérivation 2/2 (fonction dérivée, variations)

cours (2024) correction des exercices.
bonus : démonstration de la formule de dérivée de fonction composée
interrogation n°1&2 , devoir maison, devoir surveillé, devoirs maison rattrapage 1&2, devoir surveillé (2025)

Chapitre 6 : Suites numériques (cas des suites géométriques et arithmétiques)

cours , correction des points méthode
exercices fiche bases (corrections), fiche approfondissement (corrections sur le padlet de l’auteur), fiche 3, fiche 4 (corrigé intégré)
fiche python, archive contenant les programmes commentés
suites et intérêts l’essentiel de la théorie, Devoir maison (fichier python à compléter)
devoir surveillé , devoir surveillé (2025)
essai aide questionnaire 1, menu / versions 2 : menu

Chapitre 7 : Fonctions trigonométriques

Conseil : aller en vie scolaire acheter le super rapporteur à 2€.
cours (correction des méthodes et d’une partie des exercices )
exercices fiche 1 (corrections) fiche du site physique et maths , fiche corrigée ,
interrogation donnée par d’autres professeurs : M. Pons ici , un contrôle corrigé ici, un autre, encore un autre
devoir surveillé (2025), page d’entrainement générée par chatGPT

Chapitre 8 : Fonction exponentielle

cours (corrections méthodes / corrections exercices)
exercices fiche étudiée en classe , fiche de Madame Buffet , fiche de Jason Lapeyronnie (super détaillée),
fiche en ligne avec correction en vidéo ,
fiche exercice du site tableauxmaths.fr (avec correction intégrée),
fiche non corrigée (physique et maths),
devoir surveillé (2025),

Chapitre 9 : Produits scalaires

cours (méthodes, démonstrations et correction d’exercices)
exercices : fiche 1 (son corrigé), fiche 2 (corrigé inclus), fiche 1 (corrections),
devoir surveillé donné par Lionel Ponton ici (son corrigé)
devoir (pas très) surveillé 2024 (avec sa correction)

Chapitre 10 : Probabilités et variables aléatoires

cours (correction des exercices et points méthode)
exercices fiche 1 (corrections), fiche 2(corrigé inclus), fiche 3 (fiche très complète portant sur les deux chapitres)

Chapitre 11 : Géométrie dans le plan

cours à compléter (version avec les corrections) (pour la version complète, vous pouvez aller sur le site de M. Monka)
exercices : fiche utilisée en classe (éléments de correction) fiche non corrigée (physique et maths)
exercices en lignes avec vidéos
contrôle lycée laMerci
entrainement contrôle 2025

Bon site pour travailler en autonomie : Logamaths.fr

Pour réussir sa rentrée en classe de terminale (cahier de vacances)

SNT (2024)

août 9, 2024juin 3, 2025Julien Kergot

Lors du premier cours merci de remplir le questionnaire suivant.

règlement classe

cette année on utilisera beaucoup le langage Python. Vous pouvez utiliser PyScripter/EduPython qui est disponible dans la suite logicielle pré-installée sur votre ordinateur. Des fois, le logiciel se retrouve corrompu et il devient inutilisable. Dans ces cas on pourra se tourner vers Basthon ou refaire l’installation de PyScripter (voir à la fin de la page)

Première partie : Découverte du language Python

séquence 1 : du Scratch à Python (activité débranchée) (version anglaise)
ressource essentielle : site Basthon

séquence 2: premiers pas Python sur l’ordinateur (version anglaise)
vieux documents turtle : 1 et 2
séquence 3 : retour sur turtle (version anglaise)

Deuxième partie : Photo numériques

TP 1 : les pixels (version anglaise) (pixel Art)
TP 2 : les filtres (version anglaise) documents à télécharger
DM fin de partie : Warhol

Troisième partie : Localisation

TP 1 : Géolocalisation (ressources)
TP 2 : Cartographie (ressources)
TP 3 : Folium
évaluation : Les vacances du prof : sujet , archives de photos 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13,
TP 4 : Itinéraire , graphe à compléter, (exercices corrigés bases 1, base 2, Dijkstra 1, Dijkstra 2, Dijkstra 3, Dijkstra 4 )

Quatrième partie : Web

TP 1 : language HTML
TP 2 : language CSS
TP 1&2 : version Kergot
TP 3 : Mini Site
TP 4 : Page Rank
cours ancienne version
projet : une page sur ma passion
- consignes version 2
- Productions d’élèves (2025) : Diana , Joshua, Ilona, Amine, Clément
Projet : un page sur les réseaux sociaux
- consignes
- Productions d’élèves (2025) : Joshua

Cinquième partie : Intelligence Artificielle

Séance 1 : Initiation à l’intelligence artificielle
Séance 2 : Les Familles d’Intelligence Artificielle
Séance 3 : Éthique et Défis de l’Intelligence Artificielle
Séance 4 : Création Graphique et Textuelle avec l’Intelligence Artificielle

Sixième partie : cryptage

Divers

convertisseur de language pour pdf

Réinstallation de PyScripter
- Si le programme présent sur MCNL ne fonctionne plus, il est conseillé d’en refaire l’installation. Une fois que ça sera fait, vous n’aurez plus à passer par MCNL, et votre ordinateur gérera mieux vos tentatives de programmation
- première étape : installer le compilateur Python
  - – Aller sur le site officiel : ici
  - – cliquer sur le gros bouton jaune
  - – une fois le téléchargement effectué, executer le programme téléchargé
  - – assurez vous bien que les cases en bas de la petite fenêtre soient cochées (Use Admin privilege when installing py.exe et Add Python.exe to PATH)
- deuxième étape : installer PyScripter
  - – aller sur le site officiel : ici
  - – télécharger le programme est executer le fichier récupéré.
- Par la suite régulièrement vous serez amenés à devoir utiliser des librairies non préinstallées. Avec PyScripter ça sera un jeu d’enfant. Il vous suffit de choisir le menu Outil/Tool, puis l’option Outil/Tool, et enfin install Packages with pip

2nde Maths (2024)

août 9, 2024avril 20, 2025Julien Kergot

pour préparer une rentrée réussie en seconde (à l’attention des élèves qui n’ont pas encore fait leur rentrée)

Lors du premier cours merci de remplir le questionnaire suivant.

Version numérique du règlement et conseils distribué durant le premier cours.

fournitures :

plusieurs cahiers petit ou grand format suivant vos préférences ou un classeur grand format.
tube de colle.
Il y aura quelques chapitres de géométrie, pour ces cours : règle, équerre, compas
calculatrice :
- recommandée : Numworks (émulateur) achat groupé avec le lycée ICI.
- acceptée : TEXAS INSTRUMENTS TI-82 Advanced Edition Python (émulateur)

Polycopiés de cours de mathématiques

Les cours et une partie des activités de l’année seront la plupart du temps tirés du site d’Yvan Monka « Maths et tiques » pour obtenir les versions modifiables et les liens vers les vidéos explicatives pour bien réviser je vous encourage à aller consulter ses pages 2nde. Plus bas vous trouverez les autres documents : fiches de synthèses, contrôles et devoir maison, exercices.