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

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