suppression ancien fichier cours Pile & File, et ajout des sujets bacs NSI

Pile_File/Cours/README.md

@@ -1,103 +0,0 @@
-# Structure de données : Pile et File
-
-> Structures essentielles pour résoudre des problèmes où l’ordre de traitement des données est crucial, comme la gestion des processus ou la navigation dans des graphes, les piles et files permettent de stocker et manipuler des données selon des règles spécifiques. La pile suit un principe **LIFO** (Last In, First Out), tandis que la file suit un principe **FIFO** (First In, First Out).
-
-## Le programme
-
-<img src="../Images/bo_1.png" alt="BO_Pile & File" style="zoom:67%;" />
-
-
-
-
-
-<img src="../Images/bo_2.png" alt="BO_Pile&File_2" style="zoom:67%;" />
-
-
-
-
-
-## 1. Rappel :
-
-<u>**Structure de données**</u> : Collection d'information dans laquelle il est possible de stocker, traiter, organiser, extraire des données.
-
-Les structures de données connues à ce jour sont : Les tableaux, les dictionnaires, les chaînes de caractères, les n-uplets. Chacune de ces structures possèdent des caractéristiques propres qui créent des avantages et des inconvénients selon la situation.
-
-De plus, ces types sont natifs à python, et aux autres langages selon les cas. Nous n'avons donc ici aucune idée de comment le type *dict* ou *tuple* est crée par exemple.
-
-Les structures de données Pile et File ne sont pas natives à python et nous aurons donc besoin de les implémenter.
-
-## 2. Interface et implémentation : 
-
-Ces deux termes sont particulier et très important pour ce chapitre. Alors un petit rappel n'est pas de trop.
-
-<u>**Interface :**</u> L'interface d'un type est définie par les méthodes qui lui sont associées. 
-
-**<u>Implémentation :</u>** L'implémentation d'un type est la manière dont on va le coder.
-
-Il faut bien faire la distinction entre les deux termes.
-
-## 3. Pile
-
-### 3. 1. Définition
-
-Une pile est une structure de données dans la quelle les derniers éléments entrant dans la structure seront les premiers à en sortir, nous appelons ce principe **LIFO (Last In First Out)**. Afin d'imager cette structure nous pouvons penser à un pile d'assiettes par exemple.
-
-![image-20220729234146926](../Images/Pile.png)
-
-Ici seul le premier élément est accessible.  
-
-### 3. 2. Interface
-
-Méthodes associées à la pile :
-
-- Empile : Méthode permettant d'empiler un élément.
-  - L'élément sera positionné au haut de la pile
-- Depile : Méthode permettant d'enlever un élément.
-  - L'élément enlever sera celui en haut de la pile.
-
-- Est_vide : Permet de savoir si la pile est vide ou non
-
-On peut ajouter d'autres méthodes :
-
-- Taille : Permet de savoir le nombre d'élément de la pile
-- Top : Permet de connaître l'élément au dessus de la pile.
-
-## 3. File
-
-### 3. 1. Définition
-
-Une file est une structure de données dans la quelle les derniers éléments entrant dans la structure seront les dernier à en sortir, nous appelons ce principe **FIFO (First In First Out)**. Afin d'imager cette structure nous pouvons penser à un file de voiture sur une route par exemple.
-
-![File](../Images/File.png)
-
-Ici seul le premier élément peut sortir de la structure.    
-
-### 3. 2. Interface
-
-Méthodes associées à la pile :
-
-- Enfile: Méthode permettant d'enfile un élément.
-  - L'élément sera positionné au haut de la file
-- Defile: Méthode permettant d'enlever un élément.
-  - L'élément enlever sera celui en bas de la file.
-
-- Est_vide : Permet de savoir si la file est vide ou non
-
-On peut ajouter d'autres méthodes :
-
-- Taille : Permet de savoir le nombre d'élément de la file
-- Top : Permet de connaître l'élément au dessus de la file.
-
-## 4. Conclusion
-
-Les deux structures ont une interface très semblable. Seul le principe FIFO / LIFO peut les différencier. 
-
-La suite du chapitre se concentrera sur l'utilisation de ses structures et leurs implémentations.
-
----------
-
-Auteurs : Florian Mathieu, Timothée Decoster, Enzo Frémaux
-
-Licence CC BY NC
-
-<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d’Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.

Routage/animation_dijkstra.py

@@ -1,55 +0,0 @@
-import networkx as nx
-import matplotlib.pyplot as plt
-import matplotlib.animation as animation
-
-# Création du graphe
-G = nx.DiGraph()
-edges = [
-    (0, 1, 4), (0, 2, 1),
-    (2, 1, 2), (1, 3, 1),
-    (2, 3, 5), (3, 4, 3)
-]
-G.add_weighted_edges_from(edges)
-
-# Position des nœuds pour affichage
-pos = nx.spring_layout(G, seed=42)
-labels = {n: str(n) for n in G.nodes()}
-
-# Initialisation de la figure
-fig, ax = plt.subplots(figsize=(6, 6))
-
-# Algorithme de Dijkstra avec animation
-def dijkstra_animation(start_node=0):
-    distances = {node: float('inf') for node in G.nodes()}
-    distances[start_node] = 0
-    visited = set()
-    steps = []
-    
-    while len(visited) < len(G.nodes()):
-        min_node = min((node for node in distances if node not in visited), key=lambda x: distances[x])
-        visited.add(min_node)
-        
-        for neighbor in G.neighbors(min_node):
-            new_distance = distances[min_node] + G[min_node][neighbor]["weight"]
-            if new_distance < distances[neighbor]:
-                distances[neighbor] = new_distance
-        
-        steps.append((visited.copy(), [(min_node, v) for v in G.neighbors(min_node)]))
-    
-    return steps
-
-steps = dijkstra_animation()
-
-def update(frame):
-    ax.clear()
-    visited, edges = steps[frame]
-    node_colors = ["green" if n in visited else "lightblue" for n in G.nodes()]
-    edge_colors = ["red" if (u, v) in edges else "black" for u, v in G.edges()]
-    
-    nx.draw(G, pos, with_labels=True, labels=labels, node_size=800, 
-            node_color=node_colors, edge_color=edge_colors, font_size=14, font_weight="bold", ax=ax)
-    edge_labels = {(u, v): G[u][v]["weight"] for u, v in G.edges()}
-    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels, font_size=12, ax=ax)
-
-ani = animation.FuncAnimation(fig, update, frames=len(steps), repeat=False, interval=1000)
-plt.show()

Sujet_bac/Pratique/BNS_2025/25-NSI-1/25-NSI-1.py

@@ -0,0 +1,18 @@
+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
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-10/sujet-10.py

@@ -0,0 +1,19 @@
+alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+
+def position_alphabet(lettre):
+    '''Renvoie la position de la lettre dans l'alphabet'''
+    return ord(lettre) - ord('A')
+
+def cesar(message, decalage):
+    '''Renvoie le message codé par la méthode de César
+    pour le decalage donné'''
+    resultat = ''
+    for ... in message: 
+        if 'A' <= c and c <= 'Z':
+            indice = (...) % 26 
+            resultat = resultat + alphabet[indice]
+        else:
+            resultat = ... 
+    return resultat
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-11/25-NSI-11.py

@@ -0,0 +1,19 @@
+def somme_max(tab):
+    n = len(tab)
+    sommes_max = [0]*n
+    sommes_max[0] = tab[0]
+    # on calcule la plus grande somme se terminant en i
+    for i in range(1,n):
+        if ... + ... > ...: 
+            sommes_max[i] = ... 
+        else:
+            sommes_max[i] = ... 
+    # on en déduit la plus grande somme de celles-ci
+    maximum = 0
+    for i in range(1, n):
+        if ... > ...: 
+            maximum = i
+
+    return sommes_max[...] 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-12/25-NSI-12.py

@@ -0,0 +1,11 @@
+def traduire_romain(nombre):
+    """ Renvoie l'écriture décimale du nombre donné en chiffres
+    romains """
+    if len(nombre) == 1:
+        return ... 
+    elif romains[nombre[0]] >= ...: 
+        return romains[nombre[0]] + ... 
+    else:
+        return ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-13/25-NSI-13.py

@@ -0,0 +1,16 @@
+def insere(tab, a):
+    """
+    Insère l'élément a (int) dans le tableau tab (list)
+    trié par ordre croissant à sa place et renvoie le
+    nouveau tableau.
+    """
+    tab_a = [ a ] + tab # nouveau tableau contenant a 
+                        # suivi des éléments de tab
+    i = 0
+    while i < ... and a > ...: 
+        tab_a[i] = ... 
+        tab_a[i+1] = a
+        i = ... 
+    return tab_a
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-14/25-NSI-14.py

@@ -0,0 +1,37 @@
+def nombre_lignes(image):
+    '''renvoie le nombre de lignes de l'image'''
+    return ... 
+
+def nombre_colonnes(image):
+    '''renvoie la largeur de l'image'''
+    return ... 
+
+def negatif(image):
+    '''renvoie le negatif de l'image sous la forme
+       d'une liste de listes'''
+    # on cree une image de 0 aux memes dimensions 
+    # que le parametre image
+    nouvelle_image = [[0 for k in range(nombre_colonnes(image))]
+         for i in range(nombre_lignes(image))]
+
+    for i in range(nombre_lignes(image)):
+        for j in range(...): 
+            nouvelle_image[i][j] = ... 
+    return nouvelle_image
+
+def binaire(image, seuil):
+    '''renvoie une image binarisee de l'image sous la forme
+       d'une liste de listes contenant des 0 si la valeur
+       du pixel est strictement inferieure au seuil et 255 sinon'''
+    nouvelle_image = [[0] * nombre_colonnes(image)
+                      for i in range(nombre_lignes(image))]
+
+    for i in range(nombre_lignes(image)):
+        for j in range(...): 
+            if image[i][j] < ... : 
+                nouvelle_image[i][j] = ... 
+            else:
+                nouvelle_image[i][j] = ... 
+    return nouvelle_image
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-15/25-NSI-15.py

@@ -0,0 +1,15 @@
+def chercher(tab, x, i, j):
+    '''Renvoie l'indice de x dans tab, si x est dans tab, 
+    None sinon.
+    On suppose que tab est trié dans l'ordre croissant.'''
+    if i > j:
+        return None
+    m = (i + j) // ... 
+    if ... < x: 
+        return chercher(tab, x, ... , ...) 
+    elif tab[m] > x:
+        return chercher(tab, x, ... , ...) 
+    else:
+        return ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-16/25-NSI-16.py

@@ -0,0 +1,17 @@
+def ligne_suivante(ligne):
+    '''Renvoie la ligne suivant ligne du triangle de Pascal'''
+    ligne_suiv = [...] 
+    for i in range(...): 
+        ligne_suiv.append(...) 
+    ligne_suiv.append(...) 
+    return ligne_suiv
+
+def pascal(n):
+    '''Renvoie le triangle de Pascal de hauteur n'''
+    triangle = [ [1] ]
+    for k in range(...): 
+        ligne_k = ... 
+        triangle.append(ligne_k)
+    return triangle
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-17/sujet-17.py

@@ -0,0 +1,13 @@
+def ajoute(indice, element, tab):
+    '''Renvoie un nouveau tableau obtenu en insérant
+    element à l'indice indice dans le tableau tab.'''
+    nbre_elts = len(tab)
+    tab_ins = [0] * (nbre_elts + 1)
+    for i in range(indice):
+        tab_ins[i] = ... 
+    tab_ins[...] = ... 
+    for i in range(indice + 1, nbre_elts + 1):
+        tab_ins[i] = ... 
+    return tab_ins
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-18/sujet-18.py

@@ -0,0 +1,18 @@
+def dichotomie(tab, x):
+    """applique une recherche dichotomique pour déterminer
+    si x est dans le tableau trié tab.
+    La fonction renvoie True si tab contient x et False sinon"""
+
+    debut = 0
+    fin = ... 
+    while debut <= fin:
+        m = ... 
+        if x == tab[m]:
+            return ... 
+        if x > tab[m]:
+            debut = ... 
+        else:
+            fin = ... 
+    return False
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-19/sujet-19.py

@@ -0,0 +1,14 @@
+def separe(tab):
+    '''Separe les 0 et les 1 dans le tableau tab'''
+    gauche = 0
+    droite = ... 
+    while gauche < droite:
+        if tab[gauche] == 0 :
+            gauche = ... 
+        else :
+            tab[gauche] = ... 
+            tab[droite] = ... 
+            droite = ... 
+    return tab
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-2/sujet-2.py

@@ -0,0 +1,36 @@
+def est_un_ordre(tab):
+    '''
+    Renvoie True si tab est de longueur n et contient tous les
+    entiers de 1 à n, False sinon
+    '''
+    n = len(tab)
+    # les entiers vus lors du parcours
+    vus = ... 
+
+    for x in tab:
+        if x < ... or x >... or ...: 
+            return False
+        ... .append(...) 
+    return True
+
+def nombre_points_rupture(ordre):
+    '''
+    Renvoie le nombre de point de rupture de ordre qui représente 
+    un ordre de gènes de chromosome
+    '''
+    # on vérifie que ordre est un ordre de gènes
+    assert ... 
+    n = len(ordre)
+    nb = 0
+    if ordre[...] != 1: # le premier n'est pas 1 
+        nb = nb + 1
+    i = 0
+    while i < ...: 
+        if ... not in [-1, 1]: # l'écart n'est pas 1 
+            nb = nb + 1
+        i = i + 1
+    if ordre[i] != ...: # le dernier n'est pas n 
+        nb = nb + 1
+    return nb
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-20/sujet-20.py

@@ -0,0 +1,37 @@
+class Carte:
+    def __init__(self, c, v):
+        """Initialise les attributs couleur (entre 1 et 4), 
+        et valeur (entre 1 et 13). """
+        self.couleur = c
+        self.valeur = v
+
+    def recuperer_valeur(self):
+        """ Renvoie la valeur de la carte : 
+        As, 2, ..., 10, Valet, Dame, Roi """
+        valeurs = ['As','2', '3', '4', '5', '6', '7', '8', 
+                   '9', '10', 'Valet', 'Dame', 'Roi']
+        return valeurs[self.valeur - 1]
+
+    def recuperer_couleur(self):
+        """ Renvoie la couleur de la carte 
+        (parmi pique, coeur, carreau, trèfle). """
+        couleurs = ['pique', 'coeur', 'carreau', 'trèfle']
+        return couleurs[self.couleur - 1]
+
+class Paquet_de_cartes:
+    def __init__(self):
+        """ Initialise l'attribut contenu avec une liste des 52
+        objets Carte possibles rangés par valeurs croissantes en
+        commençant par pique, puis cœur, carreau et trèfle. """
+        ...
+        ...
+            ...
+                ...
+
+    def recuperer_carte(self, pos):
+        """ Renvoie la carte qui se trouve à la position pos 
+        (entier compris entre 0 et 51). """
+        ...
+        ...
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-21/sujet-21.py

@@ -0,0 +1,21 @@
+def renverse(pile):
+    '''renvoie une pile contenant les mêmes éléments que pile,
+    mais dans l'ordre inverse.
+    Cette fonction détruit pile.'''
+    pile_inverse = ... 
+    while pile != []:
+        ... .append(...) 
+    return ... 
+
+
+def positifs(pile):
+    '''renvoie une pile contenant les éléments positifs de pile,
+    dans le même ordre. Cette fonction détruit pile.'''
+    pile_positifs = ... 
+    while pile != []:
+        ... = pile.pop() 
+        if ... >= 0: 
+            ...
+    return ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-22/sujet-22.py

@@ -0,0 +1,26 @@
+class AdresseIP:
+    def __init__(self, adresse):
+        self.adresse =... 
+
+    def liste_octets(self):
+        """renvoie une liste de nombres entiers,
+        la liste des octets de l'adresse IP"""
+        # Note : split découpe la chaine de caractères 
+        # en fonction du séparateur
+        return [int(i) for i in self.adresse.split(".")]
+
+    def est_reservee(self):
+        """renvoie True si l'adresse IP est une adresse
+        réservée, False sinon"""
+        reservees = [ ... ] 
+        return ... 
+
+    def adresse_suivante(self):
+        """renvoie un objet de AdresseIP avec l'adresse
+        IP qui suit l'adresse self si elle existe et None sinon"""
+        octets = ... 
+        if ... == 254: 
+            return None
+        octet_nouveau = ... + ... 
+        return AdresseIP('192.168.0.' + ...) 
+

Sujet_bac/Pratique/BNS_2025/25-NSI-23/25-NSI-23.py

@@ -0,0 +1,21 @@
+def dec_to_bin(nb_dec):
+    q, r = nb_dec // 2, nb_dec % 2
+    if q == ...: 
+        return ... 
+    else:
+        return dec_to_bin(...) + ... 
+
+def bin_to_dec(nb_bin):
+    if len(nb_bin) == 1:
+        if ... == '0': 
+            return 0
+        else:
+            return ... 
+    else:
+        if nb_bin[-1] == '0':
+            bit_droit = 0
+        else:
+            ...
+        return ... * bin_to_dec(nb_bin[:-1]) + ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-24/sujet-24.py

@@ -0,0 +1,32 @@
+class Noeud:
+    """Classe représentant un noeud d'un arbre binaire"""
+    def __init__(self, etiquette, gauche, droit):
+        """Crée un noeud de valeur etiquette avec 
+        gauche et droit comme fils."""
+        self.etiquette = etiquette
+        self.gauche = gauche
+        self.droit = droit
+
+def parcours(arbre, liste):
+    """parcours récursivement l'arbre en ajoutant les étiquettes
+    de ses noeuds à la liste passée en argument en ordre infixe."""
+    if arbre != None:
+        parcours(arbre.gauche, liste)
+        liste.append(arbre.etiquette)
+        parcours(arbre.droit, liste)
+    return liste
+
+def insere(arbre, cle):
+    """insere la cle dans l'arbre binaire de recherche
+    représenté par arbre.
+    Retourne l'arbre modifié."""
+    if arbre == None:
+        return Noeud(cle, None, None) # creation d'une feuille
+    else:
+        if ...: 
+            arbre.gauche = insere(arbre.gauche, cle)
+        else:
+            arbre.droit = ... 
+        return arbre
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-25/sujet-25.py

@@ -0,0 +1,21 @@
+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)
+
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-26/25-NSI-26.py

@@ -0,0 +1,21 @@
+from random import randint
+
+def nombre_coups():
+    '''Simule un jeu de plateau avec 12 cases et renvoie le nombre
+    nécessaire 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
+

Sujet_bac/Pratique/BNS_2025/25-NSI-27/25-NSI-27.py

@@ -0,0 +1,22 @@
+def depouille(urne):
+    '''prend en paramètre une liste de suffrages et renvoie un 
+    dictionnaire avec le nombre de voix pour chaque candidat'''
+    resultat = ... 
+    for bulletin in urne:
+        if ...: 
+            resultat[bulletin] = resultat[bulletin] + 1
+        else:
+            ...
+    return resultat
+
+def vainqueurs(election):
+    '''prend en paramètre un dictionnaire non vide avec le nombre de voix
+    pour chaque candidat et renvoie la liste des vainqueurs'''
+    nmax = 0
+    for candidat in election:
+        if ... > ... : 
+            nmax = ... 
+    liste_finale = [ nom for nom in election if ... ] 
+    return ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-28/sujet-28.py

@@ -0,0 +1,36 @@
+def voisinage(n, ligne, colonne):
+    """ Renvoie la liste des coordonnées des voisins de la case
+    (ligne, colonne) dans un grille de taille n x n,
+    en tenant compte des cases sur les bords. """
+    voisins = []
+    for dl in range(-1, 2):
+        for dc in range(-1, 2):
+            l = ligne + dl
+            c = colonne + dc
+            if (l, c) != (ligne, colonne) \
+                    and 0 <= l < n and 0 <= c < n:
+                voisins.append((l,c))
+    return voisins
+
+def incremente_voisins(grille, ligne, colonne):
+    """ Incrémente de 1 toutes les cases voisines d'une bombe."""
+    voisins = ... 
+    for l, c in voisins:
+        if grille[l][c] != ...: # si ce n'est pas une bombe 
+            ...  # on ajoute 1 à sa valeur 
+
+def genere_grille(bombes):
+    """ Renvoie une grille de démineur de taille nxn où n est
+    le nombre de bombes, en plaçant les bombes à l'aide de
+    la liste bombes de coordonnées (tuples) passée en
+    paramètre. """
+    n = len(bombes)
+    # Initialisation d'une grille nxn remplie de 0
+    grille = [[0 for colonne in range(n)] for ligne in range(n)]
+    # Place les bombes et calcule les valeurs des autres cases
+    for ligne, colonne in bombes:
+        grille[ligne][colonne] = ... # place la bombe 
+        ...  # incrémente ses voisins 
+    return grille
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-29/sujet-29.py

@@ -0,0 +1,16 @@
+def trouver_intrus(tab, g, d):
+    """Renvoie la valeur de l'intrus situé entre les indices g et d 
+    dans le tableau tab où :
+    tab vérifie les conditions de l'exercice,
+    g et d sont des multiples de 3."""
+    if g == d:
+        return ... 
+    else:
+        nombre_de_triplets = (d - g) // ... 
+        indice = g + 3 * (nombre_de_triplets // 2)
+        if ...: 
+            return ... 
+        else:
+            return ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-3/sujet-3.py

@@ -0,0 +1,14 @@
+def eleves_du_mois(eleves, notes):
+    note_maxi = 0
+    meilleurs_eleves = ... 
+
+    for i in range(...): 
+        if notes[i] == ...: 
+            meilleurs_eleves.append(...) 
+        elif notes[i] > note_maxi:
+            note_maxi = ... 
+            meilleurs_eleves = [...] 
+
+    return (note_maxi, meilleurs_eleves)
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-30/sujet-30.py

@@ -0,0 +1,29 @@
+class Expr:
+    """Classe implémentant un arbre d'expression."""
+
+    def __init__(self, g, v, d):
+        """un objet Expr possède 3 attributs :
+        - gauche : la sous-expression gauche ;
+        - valeur : la valeur de l'étiquette, opérateur ou nombre ;
+        - droite : la sous-expression droite."""
+        self.gauche = g
+        self.valeur = v
+        self.droite = d
+
+    def est_une_feuille(self):
+        """renvoie True si et seulement 
+        si le noeud est une feuille"""
+        return self.gauche is None and self.droite is None
+
+    def infixe(self):
+        """renvoie la représentation infixe de l'expression en
+        chaine de caractères"""
+        s = ... 
+        if self.gauche is not None:
+            s = s + '(' + ... .infixe() 
+        s = s + ... 
+        if ... is not None: 
+            s = s + ... + ... 
+        return s
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-31/sujet-31.py

@@ -0,0 +1,19 @@
+def parcours(adj, x, acc):
+    '''Réalise un parcours en profondeur récursif
+    du graphe donné par les listes d'adjacence adj 
+    depuis le sommet x en accumulant les sommets
+    rencontrés dans acc'''
+    if x ...: 
+        acc.append(x)
+        for y in ...: 
+            parcours(adj, ...) 
+
+def accessibles(adj, x):
+    '''Renvoie la liste des sommets accessibles dans le
+    graphe donné par les listes d'adjacence adj depuis
+    le sommet x.'''
+    acc = []
+    parcours(adj, ...) 
+    return acc
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-32/sujet-32.py

@@ -0,0 +1,12 @@
+valeurs = [100, 50, 20, 10, 5, 2, 1]
+
+def rendu_glouton(a_rendre, rang):
+    if a_rendre == 0:
+        return ... 
+    v = valeurs[rang]
+    if v <= ...: 
+        return ... + rendu_glouton(a_rendre - v, rang) 
+    else:
+        return rendu_glouton(a_rendre, ...) 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-33/25-NSI-33.py

@@ -0,0 +1,17 @@
+def empaqueter(liste_masses, c):
+    """Renvoie le nombre minimal de boîtes nécessaires pour
+    empaqueter les objets de la liste liste_masses, sachant
+    que chaque boîte peut contenir au maximum c kilogrammes"""
+    n = len(liste_masses)
+    nb_boites = 0
+    boites = [ 0 for _ in range(n) ]
+    for masse in ...: 
+        i = 0
+        while i < nb_boites and boites[i] + ... > c: 
+            i = i + 1
+        if i == nb_boites:
+            ...
+        boites[i] = ... 
+    return ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-34/sujet-34.py

@@ -0,0 +1,20 @@
+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 ", ...) 
+

Sujet_bac/Pratique/BNS_2025/25-NSI-35/25-NSI-35.py

@@ -0,0 +1,35 @@
+class Pile:
+    """Classe définissant une structure de pile."""
+    def __init__(self):
+        self.contenu = []
+
+    def est_vide(self):
+        """Renvoie un booléen indiquant si la pile est vide."""
+        return self.contenu == []
+
+    def empiler(self, v):
+        """Place l'élément v au sommet de la pile"""
+        self.contenu.append(v)
+
+    def depiler(self):
+        """
+        Retire et renvoie l'élément placé au sommet de la pile,
+        si la pile n’est pas vide. Produit une erreur sinon.
+        """
+        assert not self.est_vide()
+        return self.contenu.pop()
+
+def eval_expression(tab):
+    p = Pile()
+    for ... in tab: 
+        if element != '+' ... element != '*': 
+            p.empiler(...) 
+        else:
+            if element == ...: 
+                resultat = ... + ... 
+            else:
+                resultat = ... 
+            p.empiler(...) 
+    return ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-36/25-NSI-36.py

@@ -0,0 +1,23 @@
+class Noeud:
+    def __init__(self, etiquette):
+        '''Méthode constructeur pour la classe Noeud.
+        Crée une feuille d'étiquette donnée.'''
+        self.etiquette = etiquette
+        self.gauche = None
+        self.droit = None
+
+    def inserer(self, cle):
+        '''Insère la clé dans l'arbre binaire de recherche
+        en préservant sa structure.'''
+        if cle < self.etiquette:
+            if self.gauche != None:
+                ...
+            else:
+                self.gauche = ... 
+        else:
+            ...
+                ...
+            else:
+                ... = Noeud(cle) 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-37/25-NSI-37.py

@@ -0,0 +1,17 @@
+def tri_insertion(tab):
+    '''Trie le tableau tab par ordre croissant
+    en appliquant l'algorithme de tri par insertion'''
+    n = len(tab)
+    for i in range(1, n):
+        valeur_insertion = ... 
+        # la variable j sert à déterminer 
+        # où placer la valeur à ranger
+        j = ... 
+        # tant qu'on n'a pas trouvé la place de l'élément à
+        # insérer on décale les valeurs du tableau vers la droite
+        while j > ... and valeur_insertion < tab[...]: 
+            tab[j] = tab[j-1]
+            j = ... 
+        tab[j] = ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-38/25-NSI-38.py

@@ -0,0 +1,12 @@
+def binaire(a):
+    '''convertit un nombre entier a en sa representation 
+    binaire sous forme de chaine de caractères.'''
+    if a == 0:
+        return ... 
+    bin_a = ... 
+    while ... : 
+        bin_a = ... + bin_a 
+        a = ... 
+    return bin_a
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-39/25-NSI-39.py

@@ -0,0 +1,15 @@
+def tri(tab):
+    '''tab est un tableau d'entiers contenant des 0 et des 1.
+    La fonction trie ce tableau en plaçant tous les 0 à gauche'''
+    i = ... # premier indice de la zone non triée 
+    j = ... # dernier indice de la zone non triée 
+    while i < j:
+        if tab[i] == 0:
+            i = ... 
+        else:
+            valeur = ... 
+            tab[j] = ... 
+            ...
+            j = ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-4/sujet-4.py

@@ -0,0 +1,16 @@
+def echange(tab, i, j):
+    '''Echange les éléments d'indice i et j dans le tableau tab.'''
+    temp = ... 
+    tab[i] = ... 
+    tab[j] = ... 
+
+def tri_bulles(tab):
+    '''Trie le tableau tab dans l'ordre croissant
+    par la méthode du tri à bulles.'''
+    n = len(tab)
+    for i in range(...): 
+        for j in range(...): 
+            if ... > ...: 
+                echange(tab, j, ...) 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-40/25-NSI-40.py

@@ -0,0 +1,36 @@
+resultats = {
+    'Dupont': {
+        'DS1': [15.5, 4],
+        'DM1': [14.5, 1],
+        'DS2': [13, 4],
+        'PROJET1': [16, 3],
+        'DS3': [14, 4]
+    },
+    'Durand': {
+        'DS1': [6 , 4],
+        'DS2': [8, 4],
+        'PROJET1': [9, 3],
+        'IE1': [7, 2],
+        'DS3': [12, 4]
+    }
+}
+
+def moyenne(nom, resultats):
+    '''Renvoie la moyenne de l'élève nom, selon le dictionnaire 
+    resultats. Si nom n'est pas dans le dictionnaire, 
+    la fonction renvoie None.'''
+    if nom in ...: 
+        notes = resultats[nom]
+        if ...: # pas de notes 
+            return 0
+        total_points = ... 
+        total_coefficients = ... 
+        for ...  in notes.values(): 
+            note, coefficient = valeurs
+            total_points = total_points + ... * coefficient 
+            ... = ... + coefficient 
+        return round( ... / total_coefficients, 1 ) 
+    else:
+        return None
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-41/25-NSI-41.py

@@ -0,0 +1,43 @@
+class Carre:
+    def __init__(self, liste, n): 
+        self.ordre = n        
+        self.tableau = [[liste[i + j * n] for i in range(n)] 
+                        for j in range(n)] 
+                                   
+    def affiche(self):        
+        '''Affiche un carré''' 
+        for i in range(self.ordre): 
+            print(self.tableau[i]) 
+                                   
+    def somme_ligne(self, i): 
+        '''Calcule la somme des valeurs de la ligne i''' 
+        somme = 0             
+                                   
+        for j in range(self.ordre): 
+            somme = somme + self.tableau[i][j] 
+        return somme          
+                                   
+    def somme_col(self, j):   
+        '''Calcule la somme des valeurs de la colonne j''' 
+        somme = 0
+                                   
+        for i in range(self.ordre): 
+            somme = somme + self.tableau[i][j] 
+        return somme          
+                                   
+                                   
+    def est_semimagique(self): 
+        s = self.somme_ligne(0) 
+        #test de la somme de chaque ligne 
+        for i in range(...): 
+            if ... != s: 
+                return ... 
+                                   
+        #test de la somme de chaque colonne 
+        for j in range(...): 
+            if ... != s: 
+                return ... 
+                                   
+        return ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-42/25-NSI-42.py

@@ -0,0 +1,13 @@
+def binaire(a):
+    '''convertit un nombre entier a en sa representation 
+    binaire sous forme de chaine de caractères.'''
+    if a == 0:
+        return '0'
+    bin_a = ... 
+    while ...: 
+        bin_a = ... + bin_a 
+        a = ... 
+    return bin_a
+
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-43/sujet-43.py

@@ -0,0 +1,16 @@
+def colore_comp1(M, i, j, val):
+    if M[i][j] != 1:
+        return
+
+    M[i][j] = val
+
+    if i-1 >= 0: # propage en haut
+        colore_comp1(M, i-1, j, val)
+    if ... < len(M): # propage en bas 
+        colore_comp1(M, ..., j, val) 
+    if ...: # propage à gauche 
+        colore_comp1(M, ..., ..., val) 
+    if ...: # propage à droite 
+        ...
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-44/sujet-44.py

@@ -0,0 +1,44 @@
+coeur = [[0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0],
+         [0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0],
+         [0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0],
+         [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+         [0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0],
+         [0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0],
+         [0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0],
+         [0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0],
+         [0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0]]
+
+def affiche(dessin):
+    ''' affichage d'une grille : les 1 sont représentés par 
+        un "*" , les 0 par une espace " " '''
+    for ligne in dessin:
+        affichage = ''
+        for col in ligne:
+            if col == 1:
+                affichage = affichage + "*"
+            else:
+                affichage = affichage + " "
+        print(affichage)
+
+
+def liste_zoom(liste_depart,k):
+    '''renvoie une liste contenant k fois chaque élément de
+       liste_depart'''
+    liste_zoomee = ... 
+    for elt in ... : 
+        for i in range(k):
+            ...
+    return liste_zoomee
+
+def dessin_zoom(grille,k):
+    '''renvoie une grille où les lignes sont zoomées k fois 
+       ET répétées k fois'''
+    grille_zoomee=[]
+    for ligne in grille:
+        ligne_zoomee = ... 
+        for i in range(k):
+            ... .append(...) 
+    return grille_zoomee
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-45/sujet-45.py

@@ -0,0 +1,17 @@
+def est_cyclique(plan):
+    '''Prend en paramètre un dictionnaire `plan` correspondant à 
+    un plan d'envoi de messages (ici entre les personnes A, B, C,
+    D, E, F).
+    Renvoie True si le plan d'envoi de messages est cyclique et 
+    False sinon.'''
+    expediteur = 'A'
+    destinataire = plan[...] 
+    nb_destinataires = 1
+
+    while destinataire != expediteur:
+        destinataire = ... 
+        nb_destinataires = ... 
+
+    return nb_destinataires == ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-46/25-NSI-46.py

@@ -0,0 +1,16 @@
+pieces = [1, 2, 5, 10, 20, 50, 100, 200]
+
+def rendu_monnaie(somme_due, somme_versee):
+    '''Renvoie la liste des pièces à rendre pour rendre la monnaie
+    lorsqu'on doit rendre somme_versee - somme_due'''
+    rendu = ... 
+    a_rendre = ... 
+    i = len(pieces) - 1
+    while a_rendre > ...: 
+        while pieces[i] > a_rendre:
+            i = i - 1
+        rendu.append(...) 
+        a_rendre = ... 
+    return rendu
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-47/25-NSI-47.py

@@ -0,0 +1,18 @@
+def echange(tab, i, j):
+    '''Echange les éléments d'indice i et j dans le tableau tab.'''
+    temp = ... 
+    tab[i] = ... 
+    tab[j] = ... 
+
+def tri_selection(tab):
+    '''Trie le tableau tab dans l'ordre croissant
+    par la méthode du tri par sélection.'''
+    N = len(tab)
+    for k in range(...): 
+        imin = ... 
+        for i in range(..., N): 
+            if tab[i] < ...: 
+                imin = i
+        echange(tab, ..., ...) 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-48/25-NSI-48.py

@@ -0,0 +1,17 @@
+def distance_carre(point1, point2):
+    """ Calcule et renvoie la distance au carre entre 
+    deux points."""
+    return (...)**2 + (...)**2 
+
+def point_le_plus_proche(depart, tab):
+    """ Renvoie les coordonnées du premier point du tableau tab se 
+    trouvant à la plus courte distance du point depart."""
+    min_point = tab[0]
+    min_dist = ... 
+    for i in range(1, len(tab)):
+        if distance_carre(tab[i], depart) < ...: 
+            min_point = ... 
+            min_dist = ... 
+    return min_point
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-5/sujet-5.py

@@ -0,0 +1,16 @@
+def crible(n):
+    """Renvoie un tableau contenant tous les nombres premiers
+    plus petits que n."""
+    premiers = []
+    tab = [True] * n
+    tab[0], tab[1] = False, False
+    for i in range(n):
+        if tab[i]:
+            premiers.... 
+            multiple = ... 
+            while multiple < n:
+                tab[multiple] = ... 
+                multiple = ... 
+    return premiers
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-6/sujet-6.py

@@ -0,0 +1,22 @@
+dico = {"A": 1, "B": 2, "C": 3, "D": 4, "E": 5, "F": 6,
+        "G": 7, "H": 8, "I": 9, "J": 10, "K": 11, "L": 12,
+        "M": 13, "N": 14, "O": 15, "P": 16, "Q": 17,
+        "R": 18, "S": 19, "T": 20, "U": 21, "V": 22,
+        "W": 23, "X": 24, "Y": 25, "Z": 26}
+
+def codes_parfait(mot):
+    """Renvoie un triplet 
+    (code_additionne, code_concatene, mot_est_parfait) où :
+    - code_additionne est la somme des codes des lettres du mot ;
+    - code_concatene est le code des lettres du mot concaténées ;
+    - mot_est_parfait est un booléen indiquant si le mot est parfait."""
+    code_concatene = ""
+    code_additionne = ... 
+    for c in mot:
+        code_concatene = code_concatene + ... 
+        code_additionne = code_additionne + ... 
+    code_concatene = int(code_concatene)
+    mot_est_parfait = ... 
+    return code_additionne, code_concatene, mot_est_parfait
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-7/sujet-7.py

@@ -0,0 +1,28 @@
+def fusion(tab1,tab2):
+    '''Fusionne deux tableaux triés et renvoie
+    le nouveau tableau trié.'''
+    n1 = len(tab1)
+    n2 = len(tab2)
+    tab12 = [0] * (n1 + n2)
+    i1 = 0
+    i2 = 0
+    i = 0
+    while i1 < n1 and ...: 
+        if tab1[i1] < tab2[i2]:
+            tab12[i] = ... 
+            i1 = ... 
+        else:
+            tab12[i] = tab2[i2]
+            i2 = ... 
+        i += 1
+    while i1 < n1:
+        tab12[i] = ... 
+        i1 = i1 + 1
+        i = ... 
+    while i2 < n2:
+        tab12[i] = ... 
+        i2 = i2 + 1
+        i = ... 
+    return tab12
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-8/sujet-8.py

@@ -0,0 +1,36 @@
+class Pile:
+    """Classe définissant une structure de pile."""
+    def __init__(self):
+        self.contenu = []
+
+    def est_vide(self):
+        """Renvoie un booléen indiquant si la pile est vide."""
+        return self.contenu == []
+
+    def empiler(self, v):
+        """Place l'élément v au sommet de la pile"""
+        self.contenu.append(v)
+
+    def depiler(self):
+        """
+        Retire et renvoie l'élément placé au sommet de la pile,
+        si la pile n’est pas vide. Produit une erreur sinon.
+        """
+        assert not self.est_vide()
+        return self.contenu.pop()
+
+def bon_parenthesage(ch):
+    """Renvoie un booléen indiquant si la chaîne ch 
+    est bien parenthésée"""
+    p = Pile()
+    for c in ch:
+        if c == ...: 
+            p.empiler(c)
+        elif c == ...: 
+            if p.est_vide():
+                ...
+            else:
+                ...
+    return ... 
+
+

Sujet_bac/Pratique/BNS_2025/25-NSI-9/sujet-9.py

@@ -0,0 +1,19 @@
+def dichotomie(tab, x):
+    """
+    tab : tableau d'entiers trié dans l'ordre croissant
+    x : nombre entier
+    La fonction renvoie True si tab contient x et False sinon
+    """
+    debut = 0
+    fin = len(tab) - 1
+    while debut <= fin:
+        m = ... 
+        if x == tab[m]:
+            return ... 
+        if x > tab[m]:
+            debut = m + 1
+        else:
+            fin = ... 
+    return ... 
+
+

Sujet_bac/Pratique/corrigé/sujet_28.py

@@ -0,0 +1,47 @@
+def a_doublon(tab):
+    
+    for i in range (len(tab) -1):
+        if tab[i] == tab [i+1]:
+            return True
+    return False 
+        
+        
+##########
+
+def voisinage(n, ligne, colonne):
+    """ Renvoie la liste des coordonnées des voisins de la case
+    (ligne, colonne) dans un grille de taille n x n,
+    en tenant compte des cases sur les bords. """
+    voisins = []
+    for dl in range(-1, 2):
+        for dc in range(-1, 2):
+            l = ligne + dl
+            c = colonne + dc
+            if (l, c) != (ligne, colonne) \
+                    and 0 <= l < n and 0 <= c < n:
+                voisins.append((l,c))
+    return voisins
+
+def incremente_voisins(grille, ligne, colonne):
+    """ Incrémente de 1 toutes les cases voisines d'une bombe."""
+    voisins = ... 
+    for l, c in voisins:
+        if grille[l][c] != ...: # si ce n'est pas une bombe 
+            ...  # on ajoute 1 à sa valeur 
+
+def genere_grille(bombes):
+    """ Renvoie une grille de démineur de taille nxn où n est
+    le nombre de bombes, en plaçant les bombes à l'aide de
+    la liste bombes de coordonnées (tuples) passée en
+    paramètre. """
+    n = len(bombes)
+    # Initialisation d'une grille nxn remplie de 0
+    grille = [[0 for colonne in range(n)] for ligne in range(n)]
+    # Place les bombes et calcule les valeurs des autres cases
+    for ligne, colonne in bombes:
+        grille[ligne][colonne] = ... # place la bombe 
+        ...  # incrémente ses voisins 
+    return grille
+
+
+