TNSI : Épreuves Pratiques⚓︎
Où Trouver des Corrigés des Sujets de La BNS - Banque Nationale de Sujets ?⚓︎
Visualisation des Sujets, au format PDF, et leurs Fichiers Python correspondants⚓︎
Page de Référence: éduscol
2025⚓︎
Télécharger Toute l'année 2025: 2025_epreuves_pratiques_nsi.zip
25_NSI_01⚓︎
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
25_NSI_02⚓︎
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
25_NSI_03⚓︎
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)
25_NSI_04⚓︎
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, ...)
25_NSI_05⚓︎
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
25_NSI_06⚓︎
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
25_NSI_07⚓︎
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
25_NSI_08⚓︎
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 ...
25_NSI_09⚓︎
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 ...
25_NSI_10⚓︎
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
25_NSI_11⚓︎
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[...]
25_NSI_12⚓︎
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 ...
25_NSI_13⚓︎
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
25_NSI_14⚓︎
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
25_NSI_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 ...
25_NSI_16⚓︎
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
25_NSI_17⚓︎
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
25_NSI_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
25_NSI_19⚓︎
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
25_NSI_20⚓︎
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). """
...
...
25_NSI_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 ...
25_NSI_22⚓︎
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.' + ...)
25_NSI_23⚓︎
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]) + ...
25_NSI_24⚓︎
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
25_NSI_25⚓︎
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)
25_NSI_26⚓︎
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
25_NSI_27⚓︎
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 ...
25_NSI_28⚓︎
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
25_NSI_29⚓︎
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 ...
25_NSI_30⚓︎
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
25_NSI_31⚓︎
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
25_NSI_32⚓︎
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, ...)
25_NSI_33⚓︎
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 ...
25_NSI_34⚓︎
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 ", ...)
25_NSI_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 ...
25_NSI_36⚓︎
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)
25_NSI_37⚓︎
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] = ...
25_NSI_38⚓︎
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
25_NSI_39⚓︎
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 = ...
25_NSI_40⚓︎
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
25_NSI_41⚓︎
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 ...
25_NSI_42⚓︎
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
25_NSI_43⚓︎
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
...
25_NSI_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
25_NSI_45⚓︎
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 == ...
25_NSI_46⚓︎
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
25_NSI_47⚓︎
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, ..., ...)
25_NSI_48⚓︎
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
2024⚓︎
Télécharger Toute l'année 2024: 2024_epreuves_pratiques_nsi.zip
24_NSI_01⚓︎
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, ..., ...)
24_NSI_02⚓︎
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 == ...
24_NSI_03⚓︎
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 ...
24_NSI_04⚓︎
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
24_NSI_05⚓︎
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
24_NSI_06⚓︎
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 ...
24_NSI_07⚓︎
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] = ...
24_NSI_08⚓︎
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érande 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
24_NSI_09⚓︎
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]) + ...
24_NSI_10⚓︎
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
des "*" , les 0 par un 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
24_NSI_11⚓︎
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)
24_NSI_12⚓︎
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 ", ...)
24_NSI_13⚓︎
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
24_NSI_14⚓︎
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). """
...
...
24_NSI_15⚓︎
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
24_NSI_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, ...)
24_NSI_17⚓︎
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
24_NSI_18⚓︎
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 ...
24_NSI_19⚓︎
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
24_NSI_20⚓︎
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 1 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
24_NSI_21⚓︎
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
24_NSI_22⚓︎
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
24_NSI_23⚓︎
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 ...
24_NSI_24⚓︎
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[...]
24_NSI_25⚓︎
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
24_NSI_26⚓︎
from random import randint
def nombre_coups():
'''Simule un jeu de plateau avec 12 cases et renvoie le nombre
minimal de coups pour visiter toutes les cases.'''
nombre_cases = 12
# indique si une case a été vue
cases_vues = [ False ] * nombre_cases
nombre_cases_vues = 1
cases_vues[0] = True
case_en_cours = 0
n = ...
while ... < ...:
x = randint(1, 6)
case_en_cours = (case_en_cours + ...) % ...
if ...:
cases_vues[case_en_cours] = True
nombre_cases_vues = ...
n = ...
return n
24_NSI_27⚓︎
def colore_comp1(M, i, j, val):
if M[i][j] != 1:
return
M[i][j] = val
if i-1 >= 0: # propage à gauche
colore_comp1(M, i-1, j, val)
if ... < len(M): # propage à droite
colore_comp1(M, ..., j, val)
if ...: # propage en haut
colore_comp1(M, ..., ..., val)
if ...: # propage en bas
...
24_NSI_28⚓︎
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)
24_NSI_29⚓︎
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
24_NSI_30⚓︎
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 ...
24_NSI_31⚓︎
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 ...
24_NSI_32⚓︎
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 ...
24_NSI_33⚓︎
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
24_NSI_34⚓︎
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
24_NSI_35⚓︎
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)
24_NSI_36⚓︎
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, ...)
24_NSI_37⚓︎
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 = ...
24_NSI_38⚓︎
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 ...
24_NSI_39⚓︎
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.' + ...)
24_NSI_40⚓︎
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 ...
24_NSI_41⚓︎
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
24_NSI_42⚓︎
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
24_NSI_43⚓︎
def voisinage(n, ligne, colonne):
""" Renvoie la liste des coordonnées des voisins de la case
(ligne, colonne) en gérant les cases sur les bords. """
voisins = []
for l in range(max(0,ligne-1), min(n, ligne+2)):
for c in range(max(0, colonne-1), min(n, colonne+2)):
if (l, c) != (ligne, colonne):
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
24_NSI_44⚓︎
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
24_NSI_45⚓︎
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
24_NSI_46⚓︎
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
24_NSI_47⚓︎
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 ...
24_NSI_48⚓︎
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
2023⚓︎
Télécharger Toute l'année 2023: 2023_epreuves_pratiques_nsi.zip
23_NSI_01⚓︎
urne = ['A', 'A', 'A','B', 'C', 'B', 'C','B', 'C', 'B']
def depouille(urne):
resultat = ...
for bulletin in urne:
if ...:
resultat[bulletin] = resultat[bulletin] + 1
else:
...
return resultat
def vainqueur(election):
vainqueur = ''
nmax = 0
for candidat in election:
if ... > ... :
nmax = ...
vainqueur = candidat
liste_finale = [nom for nom in election if election[nom] == ...]
return ...
23_NSI_02⚓︎
def positif(pile):
pile_1 = ...(pile)
pile_2 = ...
while pile_1 != []:
x = ...
if ... >= 0:
pile_2.append(...)
while pile_2 != ...:
x = pile_2.pop()
...
return pile_1
23_NSI_03⚓︎
coeur = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[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],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
def affiche(dessin):
''' affichage d'une grille : les 1 sont représentés par
des " *" , les 0 par deux espaces " "
La valeur "" donnée au paramètre end permet
de ne pas avoir de saut de ligne. '''
for ligne in dessin:
for col in ligne:
if col == 1:
print(" *", end="")
else:
print(" ", end="")
print()
def zoomListe(liste_depart, k):
'''renvoie une liste contenant k fois chaque
élément de liste_depart'''
liste_zoom = ...
for elt in ... :
for i in range(k):
...
return liste_zoom
def zoomDessin(grille, k):
'''renvoie une grille ou les lignes sont zoomées k fois
ET répétées k fois'''
grille_zoom=[]
for elt in grille:
liste_zoom = ...
for i in range(k):
... .append(...)
return grille_zoom
23_NSI_04⚓︎
coeur = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
[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],
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
def affiche(dessin):
''' affichage d'une grille : les 1 sont représentés par
des " *" , les 0 par deux espaces " "
La valeur "" donnée au paramètre end permet
de ne pas avoir de saut de ligne. '''
for ligne in dessin:
for col in ligne:
if col == 1:
print(" *", end="")
else:
print(" ", end="")
print()
def zoomListe(liste_depart, k):
'''renvoie une liste contenant k fois chaque
élément de liste_depart'''
liste_zoom = ...
for elt in ... :
for i in range(k):
...
return liste_zoom
def zoomDessin(grille, k):
'''renvoie une grille ou les lignes sont zoomées k fois
ET répétées k fois'''
grille_zoom=[]
for elt in grille:
liste_zoom = ...
for i in range(k):
... .append(...)
return grille_zoom
23_NSI_05⚓︎
img=[[20, 34, 254, 145, 6], [23, 124, 237, 225, 69], [197, 174, 207, 25, 87], [255, 0, 24, 197, 189]]
def nbLig(image):
'''renvoie le nombre de lignes de l'image'''
return ...
def nbCol(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
L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))]
for i in range(nbLig(image)):
for j in range(...):
L[i][j] = ...
return L
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 1 sinon'''
# on cree une image de 0 aux memes dimensions que le parametre image
L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))]
for i in range(nbLig(image)):
for j in range(...):
if image[i][j] < ... :
L[i][j] = ...
else:
L[i][j] = ...
return L
23_NSI_06⚓︎
from math import sqrt # import de la fonction racine carree
def distance(point1, point2):
""" Calcule et renvoie la distance entre deux points. """
return sqrt((...)**2 + (...)**2)
def plus_courte_distance(tab, depart):
""" Renvoie le point du tableau tab se trouvant a la plus
courte distance du point depart."""
point = tab[0]
min_dist = ...
for i in range (1, ...):
if distance(tab[i], depart)...:
point = ...
min_dist = ...
return point
23_NSI_07⚓︎
romains = {"I":1, "V":5, "X":10, "L":50, "C":100, "D":500, "M":1000}
def traduire_romain(nombre) :
""" Renvoie l'ecriture decimale du nombre donné en chiffres romains """
if len(nombre) == 1:
return ...
elif romains[nombre[0]] >= ... :
return romains[nombre[0]] + ...
else:
return ...
23_NSI_08⚓︎
class Pile:
"""
Classe definissant une structure de pile.
"""
def __init__(self):
self.contenu = []
def est_vide(self):
"""
Renvoie le booleen True si la pile est vide, False sinon.
"""
return self.contenu == []
def empiler(self, v):
"""
Place l'element v au sommet de la pile
"""
self.contenu.append(v)
def depiler(self):
"""
Retire et renvoie l'element place au sommet de la pile,
si la pile n'est pas vide.
"""
if 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 = p.depiler() + ...
else:
resultat = ...
p.empiler(...)
return ...
23_NSI_09⚓︎
# -*- coding: utf-8 -*-
def chercher(tab, n, i, j):
if i < 0 or j > len(tab):
return None
elif i > j:
return None
m = (i + j) // ...
if ... < n:
return chercher(tab, n, ..., ...)
elif ... > n:
return chercher(tab, n, ..., ...)
else:
return ...
23_NSI_10⚓︎
class Pile:
"""
Classe definissant une pile
"""
def __init__(self):
self.valeurs = []
def est_vide(self):
"""
Renvoie True si la pile est vide, False sinon
"""
return self.valeurs == []
def empiler(self, c):
"""
Place l'element c au sommet de la pile
"""
self.valeurs.append(c)
def depiler(self):
"""
Supprime l'element place au sommet de la pile, a condition qu'elle soit non vide
"""
if self.est_vide() == False:
self.valeurs.pop()
def parenthesage(ch):
"""
Renvoie True si la chaine ch est bien parenthesee et False sinon
"""
p = Pile()
for c in ch:
if c == ...:
p.empiler(c)
elif c == ...:
if p.est_vide():
return ...
else:
...
return p.est_vide()
23_NSI_11⚓︎
## Exercice 2
liste = [9, 5, 8, 4, 0, 2, 7, 1, 10, 3, 6]
def tri_insertion(tab):
n = len(tab)
for i in range(1, n):
valeur_insertion = tab[...]
# la variable j sert à déterminer où placer la valeur à ranger
j = ...
# tant qu'on 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] = ...
23_NSI_12⚓︎
#------------EXERCICE 1---------------------------
#---------ajout d'une valeur dans un ABR----------
class ABR:
def __init__(self, g0, v0, d0):
self.gauche = g0
self.cle = v0
self.droit = d0
def __repr__(self):
if self is None:
return ''
else:
return '(' + (self.gauche).__repr__() + ',' + str(self.cle) + ',' +(self.droit).__repr__() + ')'
n0 = ABR(None, 0, None)
n3 = ABR(None, 3, None)
n2 = ABR(None, 2, n3)
abr1 = ABR(n0, 1, n2)
def ajoute(cle, a):
pass
#------------EXERCICE 2---------------------------
#-------algorithme glouton de mise en boite-------
def empaqueter(liste_masses, c):
n = len(liste_masses)
nb_boites = 0
boites = [0]*n
for masse in ... :
i=0
while i <= nb_boites and boites[i] + ... > c:
i = i + 1
if i == nb_boites + 1:
...
boites[i] = ...
return ...
23_NSI_13⚓︎
pieces = [1, 2, 5, 10, 20, 50, 100, 200]
def rendu_monnaie(somme_due, somme_versee):
rendu = ...
a_rendre = ...
i = len(pieces) - 1
while ... :
if pieces[i] <= a_rendre :
rendu.append(...)
a_rendre = ...
else :
i = ...
return rendu
23_NSI_14⚓︎
def insere(a, tab):
""" Insère l'élément a (int) dans le tableau tab (list)
trié par ordre croissant à sa place et renvoie le
nouveau tableau. """
l = list(tab) #l contient les memes elements que tab
l.append(a)
i = ...
while a < ... and i >= 0:
l[i+1] = ...
l[i] = a
i = ...
return l
23_NSI_15⚓︎
def inverse_chaine(chaine):
result = ...
for caractere in chaine:
result = ...
return result
def est_palindrome(chaine):
inverse = inverse_chaine(chaine)
return ...
def est_nbre_palindrome(nbre):
chaine = ...
return est_palindrome(chaine)
23_NSI_16⚓︎
resultats = {'Dupont': {
'DS1': [15.5, 4],
'DM1': [14.5, 1],
'DS2': [13, 4],
'PROJET1': [16, 3],
'DS3': [14, 4]
},
'Durand': {
'DS1': [6 , 4],
'DM1': [14.5, 1],
'DS2': [8, 4],
'PROJET1': [9, 3],
'IE1': [7, 2],
'DS3': [8, 4],
'DS4':[15, 4]
}
}
def moyenne(nom, dico_result):
if nom in ...:
notes = dico_result[nom]
total_points = ...
total_coefficients = ...
for ... in notes.values():
note, coefficient = valeurs
total_points = total_points + ... * coefficient
total_coefficients = ... + coefficient
return round( ... / total_coefficients, 1 )
else:
return -1
23_NSI_17⚓︎
def pascal(n):
triangle= [[1]]
for k in range(1,...):
ligne_k = [...]
for i in range(1,k):
ligne_k.append(triangle[...][i-1]+triangle[...][...])
ligne_k.append(...)
triangle.append(ligne_k)
return triangle
23_NSI_18⚓︎
def est_un_ordre(tab):
'''
Renvoie True si tab est de longueur n et contient tous les entiers
de 1 à n, False sinon
'''
for i in range(1,...):
if ...:
return False
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
'''
assert ... # ordre n'est pas un ordre de gènes
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[...] != n: # le dernier n'est pas n
nb = nb + 1
return nb
23_NSI_19⚓︎
ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def position_alphabet(lettre):
return ord(lettre) - ord('A')
def cesar(message, decalage):
resultat = ''
for ... in message:
if 'A' <= c and c <= 'Z':
indice = ( ... ) % 26
resultat = resultat + ALPHABET[indice]
else:
resultat = ...
return resultat
23_NSI_20⚓︎
from random import randint
def nbre_coups():
n = ...
cases_vues = [0]
case_en_cours = 0
nbre_cases = 12
while ... < ...:
x = randint(1, 6)
case_en_cours = (case_en_cours + ...) % ...
if ...:
cases_vues.append(case_en_cours)
n = ...
return n
23_NSI_21⚓︎
e = Noeud(Noeud(Noeud(None, 3, None),
'*', Noeud(Noeud(None, 8, None), '+', Noeud(None, 7, None))),
'-', Noeud(Noeud(None, 2, None), '+', Noeud(None, 1, None)))
class Noeud:
'''
classe implémentant un noeud d'arbre binaire
'''
def __init__(self, g, v, d):
'''
un objet Noeud possède 3 attributs :
- gauche : le sous-arbre gauche,
- valeur : la valeur de l'étiquette,
- droit : le sous-arbre droit.
'''
self.gauche = g
self.valeur = v
self.droit = d
def __str__(self):
'''
renvoie la représentation du noeud en chaine de caractères
'''
return str(self.valeur)
def est_une_feuille(self):
'''
renvoie True si et seulement si le noeud est une feuille
'''
return self.gauche is None and self.droit is None
def expression_infixe(e):
s = ...
if e.gauche is not None:
s = '(' + s + expression_infixe(...)
s = s + ...
if ... is not None:
s = s + ... + ...
return s
23_NSI_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 est_parfait(mot):
# mot est une chaîne de caractères (en lettres majuscules)
code_concatene = ""
code_additionne = ...
for c in mot:
code_concatene = code_concatene + ...
code_additionne = ...
code_concatene = int(code_concatene)
if ... :
mot_est_parfait = True
else:
mot_est_parfait = False
return code_additionne, code_concatene, mot_est_parfait
23_NSI_23⚓︎
tab_a = [3, 3, 3, 9, 9, 9, 1, 1, 1, 7, 2, 2, 2, 4, 4, 4, 8, 8, 8, 5, 5, 5]
tab_b = [8, 5, 5, 5, 9, 9, 9, 18, 18, 18, 3, 3, 3]
tab_c = [5, 5, 5, 1, 1, 1, 0, 0, 0, 6, 6, 6, 3, 8, 8, 8]
def trouver_intrus(tab, g, d):
'''
Renvoie la valeur de l'intrus situe entre les indices g et d
dans la liste tab ou :
tab verifie 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 ...
23_NSI_24⚓︎
def fusion(lst1, lst2):
n1 = len(lst1)
n2 = len(lst2)
lst12 = [0] * (n1 + n2)
i1 = 0
i2 = 0
i = 0
while i1 < n1 and ... :
if lst1[i1] < lst2[i2]:
lst12[i] = ...
i1 = ...
else:
lst12[i] = lst2[i2]
i2 = ...
i += 1
while i1 < n1:
lst12[i] = ...
i1 = i1 + 1
i = ...
while i2 < n2:
lst12[i] = ...
i2 = i2 + 1
i = ...
return lst12
23_NSI_25⚓︎
class Arbre:
def __init__(self, etiquette):
self.v = etiquette
self.fg = None
self.fd = None
def parcours(arbre, liste):
if arbre != None:
parcours(arbre.fg, liste)
liste.append(arbre.v)
parcours(arbre.fd, liste)
return liste
def insere(arbre, cle):
""" arbre est une instance de la classe Arbre qui implémente
un arbre binaire de recherche.
"""
if ...:
if ...:
insere(arbre.fg, cle)
else:
arbre.fg = Arbre(cle)
else:
if ...:
insere(arbre.fd, cle)
else:
arbre.fd = Arbre(cle)
23_NSI_26⚓︎
def dichotomie(tab, x):
"""
tab : tableau d'entiers trie 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 ...
23_NSI_27⚓︎
def separe(tab):
gauche = 0
droite = ...
while gauche < droite :
if tab[gauche] == 0 :
gauche = ...
else :
tab[gauche], tab[droite] = ...
droite = ...
return tab
23_NSI_28⚓︎
def dichotomie(tab, x):
"""
tab : tableau trié dans l’ordre croissant
x : nombre entier
La fonction renvoie True si tab contient x et False sinon
"""
# cas du tableau vide
if ...:
return False, 1
# cas où x n'est pas compris entre les valeurs extrêmes
if (x < tab[0]) or ...:
return False, 2
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 ...
23_NSI_29⚓︎
class Arbre:
def __init__(self, etiquette):
self.v = etiquette
self.fg = None
self.fd = None
def ajoute(indice, element, liste):
nbre_elts = len(liste)
L = [0 for i in range(nbre_elts + 1)]
if ...:
for i in range(indice):
L[i] = ...
L[...] = ...
for i in range(indice + 1, nbre_elts + 1):
L[i] = ...
else:
for i in range(nbre_elts):
L[i] = ...
L[...] = ...
return L
23_NSI_30⚓︎
def binaire(a):
bin_a = ...
a = a // 2
while a ... :
bin_a = ... + bin_a
a = ...
return bin_a
23_NSI_31⚓︎
def binaire(a):
bin_a = str(...)
a = a // 2
while a ... :
bin_a = ...(a%2) + ...
a = ...
return bin_a
23_NSI_32⚓︎
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 get_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 get_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 coeur,
carreau et tréfle. """
# A compléter
def get_carte(self, pos):
""" Renvoie la carte qui se trouve à la position pos (entier compris entre 0 et 51). """
# A compléter
23_NSI_33⚓︎
def tri_selection(tab):
N = len(tab)
for k in range(...):
imin = ...
for i in range(... , N):
if tab[i] < ... :
imin = i
... , tab[imin] = tab[imin] , ...
23_NSI_34⚓︎
def tri(tab):
# i est le premier indice de la zone non triee,
# j est le dernier indice de cette zone non triée.
# Au debut, la zone non triee est le tableau complet.
i= ...
j= ...
while i != j :
if tab[i] == 0:
i= ...
else :
valeur = tab[j]
tab[j] = ...
...
j= ...
...
23_NSI_35⚓︎
## Exercice 2
c2 = [[1, 7], [7, 1]]
c3 = [[3, 4, 5], [4, 4, 4], [5, 4, 3]]
c3bis = [[2, 9, 4], [7, 0, 3], [6, 1, 8]]
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 ...
23_NSI_36⚓︎
def propager(M, i, j, val):
if M[i][j] == ...:
M[i][j] = val
# l'element en haut fait partie de la composante
if i-1 >= 0 and M[i-1][j] == ...:
propager(M, i-1, j, val)
# l'element en bas fait partie de la composante
if ... < len(M) and M[i+1][j] == 1:
propager(M, ..., j, val)
# l'element à gauche fait partie de la composante
if ... and M[i][j-1] == 1:
propager(M, ..., ..., val)
# l'element à droite fait partie de la composante
if ... and ...:
propager(..., ..., ..., ...)
23_NSI_37⚓︎
class AdresseIP:
def __init__(self, adresse):
self.adresse = ...
def liste_octet(self):
"""renvoie une liste de nombres entiers,
la liste des octets de l'adresse IP"""
return [int(i) for i in self.adresse.split(".")]
def est_reservee(self):
"""renvoie True si l'adresse IP est une adresse
reservee, False sinon"""
return ... or ...
def adresse_suivante(self):
"""renvoie un objet de AdresseIP avec l'adresse
IP qui suit l'adresse self
si elle existe et False sinon"""
if ... < 254:
octet_nouveau = ... + ...
return AdresseIP('192.168.0.' + ...)
else:
return False
23_NSI_38⚓︎
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_destinaires = 1
while destinataire != ...:
destinataire = plan[ ... ]
nb_destinaires += ...
return nb_destinaires == ...
23_NSI_39⚓︎
def pantheon(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)
eleves_nsi = ['a','b','c','d','e','f','g','h','i','j']
notes_nsi = [30, 40, 80, 60, 58, 80, 75, 80, 60, 24]
23_NSI_40⚓︎
class Noeud:
def __init__(self, valeur):
'''Méthode constructeur pour la classe Noeud.
Paramètre d'entrée : valeur (str)'''
self.valeur = valeur
self.gauche = None
self.droit = None
def getValeur(self):
'''Méthode accesseur pour obtenir la valeur du noeud
Aucun paramètre en entrée'''
return self.valeur
def droitExiste(self):
'''Méthode renvoyant True si l'enfant droit existe
Aucun paramètre en entrée'''
return (self.droit is not None)
def gaucheExiste(self):
'''Méthode renvoyant True si l'enfant gauche existe
Aucun paramètre en entrée'''
return (self.gauche is not None)
def inserer(self, cle):
'''Méthode d'insertion de clé dans un arbre binaire de recherche
Paramètre d'entrée : cle (int)'''
if cle < ...:
# on insère à gauche
if self.gaucheExiste():
# on descend à gauche et on retente l'insertion de la clé
...
else:
# on crée un fils gauche
self.gauche = ...
elif cle > ... :
# on insère à droite
if ... :
# on descend à droite et on retente l'insertion de la clé
...
else:
# on crée un fils droit
... = Noeud(cle)
arbre = Noeud(7)
for cle in (3, 9, 1, 6):
arbre.inserer(cle)
23_NSI_41⚓︎
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, ...)
23_NSI_42⚓︎
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 + ...
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 etait ", ...)
print("Nombre d'essais: ", ...)
else:
print("Perdu ! Le nombre etait ", ...)
23_NSI_43⚓︎
def tri_bulles(T):
'''
Renvoie le tableau T trié par ordre croissant
'''
n = len(T)
for i in range(...,...,-1):
for j in range(i):
if T[j] > T[...]:
... = T[j]
T[j] = T[...]
T[j+1] = temp
return T
23_NSI_44⚓︎
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.append(...)
for multiple in range(2 * i, n, ...):
tab[multiple] = ...
return premiers
assert crible(40) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
23_NSI_45⚓︎
## Exercice 1
notes_eval = [2, 0, 5, 9, 6, 9, 10, 5, 7, 9, 9, 5, 0, 9, 6, 5, 4]
## Exercice 2
def dec_to_bin (nb_dec):
q, r = nb_dec // 2, nb_dec % 2
if q == ...:
return str(r)
else:
return dec_to_bin(...) + ...
def bin_to_dec(nb_bin):
if nb_bin == '0':
return 0
elif ...:
return 1
else:
if nb_bin[-1] == '0':
bit_droit = 0
else:
bit_droit = ...
return ... * bin_to_dec(nb_bin[:-1]) + ...
2022⚓︎
Télécharger Toute l'année 2022: 2022_epreuves_pratiques_nsi.zip
22_NSI_01⚓︎
Pieces = [100,50,20,10,5,2,1]
def rendu_glouton(arendre, solution=[], i=0):
if arendre == 0:
return ...
p = pieces[i]
if p <= ... :
solution.append(...)
return rendu_glouton(arendre - p, solution, i)
else :
return rendu_glouton(arendre, solution, ...)
22_NSI_02⚓︎
def pascal(n):
C= [[1]]
for k in range(1,...):
Ck = [...]
for i in range(1,k):
Ck.append(C[...][i-1]+C[...][...] )
Ck.append(...)
C.append(Ck)
return C
22_NSI_03⚓︎
class Noeud:
def __init__(self, g, v, d):
self.gauche = g
self.valeur = v
self.droit = d
def __str__(self):
return str(self.valeur)
def est_une_feuille(self):
'''Renvoie True si et seulement si le noeud est une feuille'''
return self.gauche is None and self.droit is None
def expression_infixe(e):
s = ...
if e.gauche is not None:
s = s + expression_infixe(...)
s = s + ...
if ... is not None:
s = s + ...
if ...:
return s
return '('+ s +')'
22_NSI_04⚓︎
def propager(M, i, j, val):
if M[i][j]== ...:
return
M[i][j]=val
# l'élément en haut fait partie de la composante
if ((i-1) >= 0 and M[i-1][j] == ...):
propager(M, i-1, j, val)
# l'élément en bas fait partie de la composante
if ((...) < len(M) and M[i+1][j] == 1):
propager(M, ..., j, val)
# l'élément à gauche fait partie de la composante
if ((...) >= 0 and M[i][j-1] == 1):
propager(M, i, ..., val)
# l'élément à droite fait partie de la composante
if ((...) < len(M) and M[i][j+1] == 1):
propager(M, i, ..., val)
22_NSI_05⚓︎
class Carte:
"""Initialise Couleur (entre 1 à 4), et Valeur (entre 1 à 13)"""
def __init__(self, c, v):
self.Couleur = c
self.Valeur = v
"""Renvoie le nom de la Carte As, 2, ... 10,
Valet, Dame, Roi"""
def getNom(self):
if ( self.Valeur > 1 and self.Valeur < 11):
return str( self.Valeur)
elif self.Valeur == 11:
return "Valet"
elif self.Valeur == 12:
return "Dame"
elif self.Valeur == 13:
return "Roi"
else:
return "As"
"""Renvoie la couleur de la Carte (parmi pique, coeur, carreau, trefle"""
def getCouleur(self):
return ['pique', 'coeur', 'carreau', 'trefle' ][self.Couleur - 1]
class PaquetDeCarte:
def __init__(self):
self.contenu = []
"""Remplit le paquet de cartes"""
def remplir(self):
#A compléter
"""Renvoie la Carte qui se trouve à la position donnée"""
def getCarteAt(self, pos):
#A compléter
22_NSI_06⚓︎
def recherche(gene, seq_adn):
n = len(seq_adn)
g = len(gene)
i = ...
trouve = False
while i < ... and trouve == ... :
j = 0
while j < g and gene[j] == seq_adn[i+j]:
...
if j == g:
trouve = True
...
return trouve
22_NSI_07⚓︎
def tri_bulles(T):
n = len(T)
for i in range(...,...,-1):
for j in range(i):
if T[j] > T[...]:
... = T[j]
T[j] = T[...]
T[j+1] = temp
return T
22_NSI_08⚓︎
def insere(a, tab):
l = list(tab) #l contient les mêmes éléments que tab
l.append(a)
i = ...
while a < ... and i >= 0:
l[i+1] = ...
l[i] = a
i = ...
return l
22_NSI_09⚓︎
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 est_parfait(mot) :
#mot est une chaîne de caractères (en lettres majuscules)
code_c = ""
code_a = ???
for c in mot :
code_c = code_c + ???
code_a = ???
code_c = int(code_c)
if ??? :
mot_est_parfait = True
else :
mot_est_parfait = False
return [code_a, code_c, mot_est_parfait]
22_NSI_10⚓︎
def fusion(L1,L2):
n1 = len(L1)
n2 = len(L2)
L12 = [0]*(n1+n2)
i1 = 0
i2 = 0
i = 0
while i1 < n1 and ... :
if L1[i1] < L2[i2]:
L12[i] = ...
i1 = ...
else:
L12[i] = L2[i2]
i2 = ...
i += 1
while i1 < n1:
L12[i] = ...
i1 = i1 + 1
i = ...
while i2 < n2:
L12[i] = ...
i2 = i2 + 1
i = ...
return L12
22_NSI_11⚓︎
ALPHABET='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def position_alphabet(lettre):
return ALPHABET.find(lettre)
def cesar(message, decalage):
resultat = ''
for ... in message :
if lettre in ALPHABET :
indice = ( ... )%26
resultat = resultat + ALPHABET[indice]
else:
resultat = ...
return resultat
22_NSI_12⚓︎
def tri(tab):
#i est le premier indice de la zone non triee, j le dernier indice.
#Au debut, la zone non triee est le tableau entier.
i= ...
j= ...
while i != j :
if tab[i]== 0:
i= ...
else :
valeur = tab[j]
tab[j] = ...
...
j= ...
...
22_NSI_13⚓︎
class Maillon :
def __init__(self,v) :
self.valeur = v
self.suivant = None
class File :
def __init__(self) :
self.dernier_file = None
def enfile(self,element) :
nouveau_maillon = Maillon(...)
nouveau_maillon.suivant = self.dernier_file
self.dernier_file = ...
def est_vide(self) :
return self.dernier_file == None
def affiche(self) :
maillon = self.dernier_file
while maillon != ... :
print(maillon.valeur)
maillon = ...
def defile(self) :
if not self.est_vide() :
if self.dernier_file.suivant == None :
resultat = self.dernier_file.valeur
self.dernier_file = None
return resultat
maillon = ...
while maillon.suivant.suivant != None :
maillon = maillon.suivant
resultat = ...
maillon.suivant = None
return resultat
return None
22_NSI_14⚓︎
def est_cyclique(plan):
'''
Prend en paramètre un dictionnaire `plan` correspondant
à un plan d'envoi de messages entre `N` personnes A, B, C,
D, E, F ...(avec N <= 26).
Renvoie True si le plan d'envoi de messages est cyclique
et False sinon.
'''
personne = 'A'
N = len(...)
for i in range(...):
if plan[...] == ...:
return ...
else:
personne = ...
return ...
22_NSI_15⚓︎
def binaire(a):
bin_a = str(...)
a = a // 2
while a ... :
bin_a = ...(a%2) + ...
a = ...
return bin_a
22_NSI_16⚓︎
def positif(T):
T2 = ...(T)
T3 = ...
while T2 != []:
x = ...
if ... >= 0:
T3.append(...)
T2 = []
while T3 != ...:
x = T3.pop()
...
print('T = ',T)
return T2
22_NSI_17⚓︎
class Noeud:
'''
Classe implémentant un noeud d'arbre binaire
disposant de 3 attributs :
- valeur : la valeur de l'étiquette,
- gauche : le sous-arbre gauche.
- droit : le sous-arbre droit.
'''
def __init__(self, v, g, d):
self.valeur = v
self.gauche = g
self.droite = d
class ABR:
'''
Classe implémentant une structure
d'arbre binaire de recherche.
'''
def __init__(self):
'''Crée un arbre binaire de recherche vide'''
self.racine = None
def est_vide(self):
'''Renvoie True si l'ABR est vide et False sinon.'''
return self.racine is None
def parcours(self, tab = []):
'''
Renvoie la liste tab complétée avec tous les
éléments de
l'ABR triés par ordre croissant.
'''
if self.est_vide():
return tab
else:
self.racine.gauche.parcours(tab)
tab.append(...)
...
return tab
def insere(self, element):
'''Insère un élément dans l'arbre binaire de recherche.'''
if self.est_vide():
self.racine = Noeud(element, ABR(), ABR())
else:
if element < self.racine.valeur:
self.racine.gauche.insere(element)
else :
self.racine.droite.insere(element)
def recherche(self, element):
'''
Renvoie True si element est présent dans l'arbre
binaire et False sinon.
'''
if self.est_vide():
return ...
else:
if element < self.racine.valeur:
return ...
elif element > self.racine.valeur:
return ...
else:
return ...
22_NSI_18⚓︎
def inverse_chaine(chaine):
result = ...
for caractere in chaine:
result = ...
return result
def est_palindrome(chaine):
inverse = inverse_chaine(chaine)
return ...
def est_nbre_palindrome(nbre):
chaine = ...
return est_palindrome(chaine)
22_NSI_19⚓︎
def chercher(T,n,i,j):
if i < 0 or ??? :
print("Erreur")
return None
if i > j :
return None
m = (i+j) // ???
if T[m] < ??? :
return chercher(T, n, ??? , ???)
elif ??? :
return chercher(T, n, ??? , ??? )
else :
return ???
22_NSI_20⚓︎
class Carre:
def __init__(self, tableau = [[]]):
self.ordre = len(tableau)
self.valeurs = tableau
def affiche(self):
'''Affiche un carré'''
for i in range(self.ordre):
print(self.valeurs[i])
def somme_ligne(self, i):
'''Calcule la somme des valeurs de la ligne i'''
return sum(self.valeurs[i])
def somme_col(self, j):
'''calcule la somme des valeurs de la colonne j'''
return sum([self.valeurs[i][j] for i in range(self.ordre)])
def est_magique(carre):
n = carre.ordre
s = carre.somme_ligne(0)
#test de la somme de chaque ligne
for i in range(..., ...):
if carre.somme_ligne(i) != s:
return ...
#test de la somme de chaque colonne
for j in range(n):
if ... != s:
return False
#test de la somme de chaque diagonale
if sum([carre.valeurs[...][...] for k in range(n)]) != s:
return False
if sum([carre.valeurs[k][n-1-k] for k in range(n)]) != s:
return False
return ...
22_NSI_21⚓︎
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 ...
22_NSI_22⚓︎
def crible(N):
"""renvoie un tableau contenant tous les nombres premiers plus petit que N"""
premiers = []
tab = [True] * N
tab[0], tab[1] = False, False
for i in range(..., N):
if tab[i] == ...:
premiers.append(...)
for multiple in range(2*i, N, ...):
tab[multiple] = ...
return premiers
assert crible(40) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
22_NSI_23⚓︎
class Pile:
"""Classe définissant une structure de pile."""
def __init__(self):
self.contenu = []
def est_vide(self):
"""Renvoie le booléen True si la pile est vide, False sinon."""
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.
"""
if 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 = p.depiler() + ...
else:
resultat = ...
p.empiler(...)
return ...
22_NSI_24⚓︎
class Pile:
""" Classe définissant une pile """
def __init__(self, valeurs=[]):
self.valeurs = valeurs
def est_vide(self):
"""Renvoie True si la pile est vide, False sinon"""
return self.valeurs == []
def empiler(self, c):
"""Place l’élément c au sommet de la pile"""
self.valeurs.append(c)
def depiler(self):
"""Supprime l’élément placé au sommet de la pile, à condition qu’elle soit non vide"""
if self.est_vide() == False:
self.valeurs.pop()
def parenthesage (ch):
"""Renvoie True si la chaîne ch est bien parenthésée et False sinon"""
p = Pile()
for c in ch:
if c == ...:
p.empiler(c)
elif c == ...:
if p.est_vide():
return ...
else:
...
return p.est_vide()
assert parenthesage("((()())(()))") == True
assert parenthesage("())(()") == False
assert parenthesage("(())(()") == False
22_NSI_25⚓︎
def trouver_intrus(tab, g, d):
'''
Renvoie la valeur de l'intrus situé entre les indices g et d
dans la liste 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 ...
22_NSI_26⚓︎
def separe(tab):
i = 0
j = ...
while i < j :
if tab[i] == 0 :
i = ...
else :
tab[i], tab[j] = ...
j = ...
return tab
22_NSI_27⚓︎
def tri_iteratif(tab):
for k in range( ... , 0, -1):
imax = ...
for i in range(0 , ... ):
if tab[i] > ... :
imax = i
if tab[imax] > ... :
... , tab[imax] = tab[imax] , ...
return tab
22_NSI_28⚓︎
def dec_to_bin(a):
bin_a = ...
a = a//2
while a ... :
bin_a = ... + bin_a
a = ...
return bin_a
22_NSI_29⚓︎
liste_eleves = ['a','b','c','d','e','f','g','h','i','j']
liste_notes = [1, 40, 80, 60, 58, 80, 75, 80, 60, 24]
def meilleures_notes():
note_maxi = 0
nb_eleves_note_maxi = ...
liste_maxi = ...
for compteur in range(...):
if liste_notes[compteur] == ...:
nb_eleves_note_maxi = nb_eleves_note_maxi + 1
liste_maxi.append(liste_eleves[...])
if liste_notes[compteur] > note_maxi:
note_maxi = liste_notes[compteur]
nb_eleves_note_maxi = ...
liste_maxi = [...]
return (note_maxi,nb_eleves_note_maxi,liste_maxi)
22_NSI_30⚓︎
def rom_to_dec (nombre):
""" Renvoie l’écriture décimale du nombre donné en chiffres romains """
dico = {"I":1, "V":5, ...}
if len(nombre) == 1:
return ...`
else:
### on supprime le premier caractère de la chaîne contenue dans la variable nombre
### et cette nouvelle chaîne est enregistrée dans la variable nombre_droite
nombre_droite = nombre[1:]
if dico[nombre[0]] >= dico[nombre[1]]:
return dico[nombre[0]] + ...
else:
return ...
assert rom_to_dec("CXLII") == 142
22_NSI_31⚓︎
def rendu_monnaie_centimes(s_due, s_versee):
pieces = [1, 2, 5, 10, 20, 50, 100, 200]
rendu = ...
a_rendre = ...
i = len(pieces) - 1
while a_rendre > ... :
if pieces[i] <= a_rendre :
rendu.append(...)
a_rendre = ...
else :
i = ...
return rendu
22_NSI_32⚓︎
class AdresseIP:
def __init__(self, adresse):
self.adresse = ...
def liste_octet(self):
"""renvoie une liste de nombres entiers,
la liste des octets de l'adresse IP"""
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"""
return ... or ...
def adresse_suivante(self):
"""renvoie un objet de AdresseIP avec l'adresse
IP qui suit l’adresse self
si elle existe et False sinon"""
if ... < 254:
octet_nouveau = ... + ...
return AdresseIP('192.168.0.' + ...)
else:
return False
22_NSI_33⚓︎
def tri_insertion(L):
n = len(L)
# cas du tableau vide
if ...:
return L
for j in range(1,n):
e = L[j]
i = j
# A l'etape j, le sous-tableau L[0,j-1] est trie
# et on insere L[j] dans ce sous-tableau en determinant
# le plus petit i tel que 0 <= i <= j et L[i-1] > L[j].
while i > 0 and L[i-1] > ...:
i = ...
# si i != j, on decale le sous tableau L[i,j-1] d'un cran
# vers la droite et on place L[j] en position i
if i != j:
for k in range(j,i,...):
L[k] = L[...]
L[i] = ...
return L
22_NSI_34⚓︎
def nbLig(image):
'''renvoie le nombre de lignes de l'image'''
return ...
def nbCol(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'''
L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))]
# on cree une image de 0 aux memes dimensions que le parametre image
for i in range(len(image)):
for j in range(...):
L[i][j] = ...
return L
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 1 sinon'''
L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))] # on cree une image de 0 aux memes dimensions que le parametre image
for i in range(len(image)):
for j in range(...):
if image[i][j] < ... :
L[i][j] = ...
else:
L[i][j] = ...
return L
22_NSI_35⚓︎
def dichotomie(tab, x):
"""
tab : tableau trie dans l'ordre croissant
x : nombre entier
La fonction renvoie True si tab contient x et False sinon
"""
# cas du tableau vide
if ...:
return False,1
# cas ou x n'est pas compris entre les valeurs extremes
if (x < tab[0]) or ...:
return False,2
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 ...
22_NSI_36⚓︎
from math import sqrt # import de la fonction racine carree
def distance(point1, point2):
""" Calcule et renvoie la distance entre deux points. """
return sqrt((...)**2 + (...)**2)
assert distance((1, 0), (5, 3)) == 5.0, "erreur de calcul"
def plus_courte_distance(tab, depart):
""" Renvoie le point du tableau tab se trouvant a la plus
courte distance du point depart."""
point = tab[0]
min_dist = ...
for i in range (1, ...):
if distance(tab[i], depart)...:
point = ...
min_dist = ...
return point
assert plus_courte_distance([(7, 9), (2, 5), (5, 2)], (0, 0)) == (2, 5), "erreur"
22_NSI_37⚓︎
urne = ['Oreilles sales', 'Oreilles sales', 'Oreilles sales',
'Extra Vomit', 'Lady Baba', 'Extra Vomit', 'Lady Baba',
'Extra Vomit', 'Lady Baba', 'Extra Vomit']
def depouille(urne):
resultat = ...
for bulletin in urne:
if ...:
resultat[bulletin] = resultat[bulletin] + 1
else:
...
return resultat
def vainqueur(election):
vainqueur = ''
nmax = 0
for candidat in election:
if ... > ... :
nmax = ...
vainqueur = candidat
liste_finale = [nom for nom in election if election[nom] == ...]
return ...
22_NSI_38⚓︎
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 + ...
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 etait ",...)
print("Nombre d'essais: ",...)
else:
print ("Perdu ! Le nombre etait ",...)
22_NSI_39⚓︎
coeur = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], \
[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], \
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
def affiche(dessin):
''' affichage d'une grille : les 1 sont repreente par
des "*" , les 0 par deux espaces " " '''
for ligne in dessin:
for col in ligne:
if col == 1:
print(" *",end="")
else:
print(" ",end="")
print()
def zoomListe(liste_depart,k):
'''renvoie une liste contenant k fois chaque
element de liste_depart'''
liste_zoom = ...
for elt in ... :
for i in range(k):
...
return liste_zoom
def zoomDessin(grille,k):
'''renvoie une grille ou les lignes sont zoomees k fois
ET repetees k fois'''
grille_zoom=[]
for elt in grille:
liste_zoom = ...
for i in range(k):
... .append(...)
return grille_zoom
22_NSI_40⚓︎
resultats = {'Dupont':{'DS1' : [15.5, 4],
'DM1' : [14.5, 1],
'DS2' : [13, 4],
'PROJET1' : [16, 3],
'DS3' : [14, 4]},
'Durand':{'DS1' : [6 , 4],
'DM1' : [14.5, 1],
'DS2' : [8, 4],
'PROJET1' : [9, 3],
'IE1' : [7, 2],
'DS3' : [8, 4],
'DS4' :[15, 4]}}
def moyenne(nom):
if nom in ...:
notes = resultats[nom]
total_points = ...
total_coefficients = ...
for ... in notes.values():
note , coefficient = valeurs
total_points = total_points + ... * coefficient
total_coefficients = ... + coefficient
return round( ... / total_coefficients , 1 )
else:
return -1
2021⚓︎
Télécharger Toute l'année 2021: 2021_epreuves_pratiques_nsi.zip
21_NSI_01⚓︎
from math import sqrt # import de la fonction racine carrée
def distance(point1, point2):
""" Calcule et renvoie la distance entre deux points. """
return sqrt((...)**2 + (...)**2)
assert distance((1, 0), (5, 3)) == 5.0, "erreur de calcul"
def plus_courte_distance(tab, depart):
""" Renvoie le point du tableau tab se trouvant à la plus
courte distance du point depart."""
point = tab[0]
min_dist = ...
for i in range (1, ...):
if distance(tab[i], depart)...:
point = ...
min_dist = ...
return point
assert plus_courte_distance([(7, 9), (2, 5), (5, 2)], (0, 0)) == [2, 5], "erreur"
21_NSI_02⚓︎
def tri(tab):
#i est le premier indice de la zone non triee, j le dernier indice.
#Au debut, la zone non triee est le tableau entier.
i= ...
j= ...
while i != j :
if tab[i]== 0:
i= ...
else :
valeur = tab[j]
tab[j] = ...
...
j= ...
...
21_NSI_03⚓︎
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 ...
21_NSI_04⚓︎
def dichotomie(tab, x):
"""
tab : tableau trié dans l’ordre croissant
x : nombre entier
La fonction renvoie True si tab contient x et False sinon
"""
# cas du tableau vide
if ...:
return False,1
# cas où x n'est pas compris entre les valeurs extrêmes
if (x < tab[0]) or ...:
return False,2
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 ...
21_NSI_05⚓︎
def tri_insertion(L):
n = len(L)
# cas du tableau vide
if ...:
return L
for j in range(1,n):
e = L[j]
i = j
# A l'étape j, le sous-tableau L[0,j-1] est trié
# et on insère L[j] dans ce sous-tableau en déterminant
# le plus petit i tel que 0 <= i <= j et L[i-1] > L[j].
while i > 0 and L[i-1] > ...:
i = ...
# si i != j, on décale le sous tableau L[i,j-1] d’un cran
# vers la droite et on place L[j] en position i
if i != j:
for k in range(j,i,...):
L[k] = L[...]
L[i] = ...
return L
21_NSI_06⚓︎
class Maillon :
def __init__(self,v) :
self.valeur = v
self.suivant = None
class File :
def __init__(self) :
self.dernier_file = None
def enfile(self,element) :
nouveau_maillon = Maillon(... , self.dernier_file)
self.dernier_file = ...
def est_vide(self) :
return self.dernier_file == None
def affiche(self) :
maillon = self.dernier_file
while maillon != ... :
print(maillon.valeur)
maillon = ...
def defile(self) :
if not self.est_vide() :
if self.dernier_file.suivant == None :
resultat = self.dernier_file.valeur
self.dernier_file = None
return resultat
maillon = ...
while maillon.suivant.suivant != None :
maillon = maillon.suivant
resultat = ...
maillon.suivant = None
return resultat
return None
21_NSI_07⚓︎
liste_eleves = ['a','b','c','d','e','f','g','h','i','j']
liste_notes = [1, 40, 80, 60, 58, 80, 75, 80, 60, 24]
def meilleures_notes():
note_maxi = 0
nb_eleves_note_maxi = ...
liste_maxi = ...
for compteur in range(...):
if liste_notes[compteur] == ...:
nb_eleves_note_maxi = nb_eleves_note_maxi + 1
liste_maxi.append(liste_eleves[...])
if liste_notes[compteur] > note_maxi:
note_maxi = liste_notes[compteur]
nb_eleves_note_maxi = ...
liste_maxi = [...]
return (note_maxi,nb_eleves_note_maxi,liste_maxi)
21_NSI_08⚓︎
Pieces = [100,50,20,10,5,2,1]
def rendu_glouton(arendre, solution=[], i=0):
if arendre == 0:
return ...
p = pieces[i]
if p <= ... :
return rendu_glouton(arendre - p, solution.append(...),i)
else :
return rendu_glouton(arendre, solution, ...)
21_NSI_09⚓︎
def pascal(n):
C= [[1]]
for k in range(1,...):
Ck = [...]
for i in range(1,k):
Ck.append(C[...][i-1]+C[...][...] )
Ck.append(...)
C.append(Ck)
return C
21_NSI_10⚓︎
def positif(T):
T2 = ...(T)
T3 = ...
while T2 != []:
x = ...
if ... >= 0:
T3.append(...)
T2 = []
while T3 != ...:
x = T3.pop()
...
print('T = ',T)
return T2
21_NSI_11⚓︎
def tri_bulles(T):
n = len(T)
for i in range(...,...,-1):
for j in range(i):
if T[j] > T[...]:
... = T[j]
T[j] = T[...]
T[j+1] = temp
return T
21_NSI_12⚓︎
def recherche(gene, seq_adn):
n = len(seq_adn)
g = len(gene)
i = ...
trouve = False
while i < ... and trouve == ... :
j = 0
while j < g and gene[j] == seq_adn[i+j]:
...
if j == g:
trouve = True
...
return trouve
21_NSI_13⚓︎
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 + ...
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 ",...)
21_NSI_14⚓︎
resultats = {'Dupont':{'DS1' : [15.5, 4],
'DM1' : [14.5, 1],
'DS2' : [13, 4],
'PROJET1' : [16, 3],
'DS3' : [14, 4]},
'Durand':{'DS1' : [6 , 4],
'DM1' : [14.5, 1],
'DS2' : [8, 4],
'PROJET1' : [9, 3],
'IE1' : [7, 2],
'DS3' : [8, 4],
'DS4' :[15, 4]}}
def moyenne(nom):
if nom in ...:
notes = resultats[nom]
total_points = ...
total_coefficients = ...
for ... in notes.values():
note , coefficient = valeurs
total_points = total_points + ... * coefficient
total_coefficients = ... + coefficient
return round( ... / total_coefficients , 1 )
else:
return -1
21_NSI_15⚓︎
class Carte:
"""Initialise Couleur (entre 1 à 4), et Valeur (entre 1 à 13)"""
def __init__(self, c, v):
self.Couleur = c
self.Valeur = v
"""Renvoie le nom de la Carte As, 2, ... 10,
Valet, Dame, Roi"""
def getNom(self):
if ( self.Valeur > 1 and self.Valeur < 11):
return str( self.Valeur)
elif self.Valeur == 11:
return "Valet"
elif self.Valeur == 12:
return "Dame"
elif self.Valeur == 13:
return "Roi"
else:
return "As"
"""Renvoie la couleur de la Carte (parmi pique, coeur, carreau, trefle"""
def getCouleur(self):
return ['pique', 'coeur', 'carreau', 'trefle' ][self.Couleur]
class PaquetDeCarte:
def __init__(self):
self.contenu = []
"""Remplit le paquet de cartes"""
def remplir(self):
#A compléter
"""Renvoie la Carte qui se trouve à la position donnée"""
def getCarteAt(self, pos):
#A compléter
21_NSI_16⚓︎
def dec_to_bin(a):
bin_a = ...
a = a//2
while a ... :
bin_a = ... + bin_a
a = ...
return bin_a
21_NSI_17⚓︎
def separe(tab):
i = 0
j = ...
while i < j :
if tab[i] == 0 :
i = ...
else :
tab[i], tab[j] = ...
j = ...
return tab
21_NSI_18⚓︎
def insere(a, tab):
l = list(tab) #l contient les mêmes éléments que tab
l.append(a)
i = ...
while a < ... :
l[i+1] = ...
l[i] = a
i = ...
return l
21_NSI_19⚓︎
ALPHABET='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
def position_alphabet(lettre):
return ALPHABET.find(lettre)
def cesar(message, decalage):
resultat = ''
for ... in message :
if lettre in ALPHABET :
indice = ( ... )%26
resultat = resultat + ALPHABET[indice]
else:
resultat = ...
return resultat
21_NSI_20⚓︎
def inverse_chaine(chaine):
result = ...
for caractere in chaine:
result = ...
return result
def est_palindrome(chaine):
inverse = inverse_chaine(chaine)
return ...
def est_nbre_palindrome(nbre):
chaine = ...
return est_palindrome(chaine)
21_NSI_21⚓︎
def binaire(a):
bin_a = str(...)
a = a // 2
while a ... :
bin_a = ...(a%2) + ...
a = ...
return bin_a
21_NSI_22⚓︎
def rendu_monnaie_centimes(s_due, s_versee):
pieces = [1, 2, 5, 10, 20, 50, 100, 200]
rendu = ...
a_rendre = ...
i = len(pieces) - 1
while a_rendre > ... :
if pieces[i] <= a_rendre :
rendu.append(...)
a_rendre = ...
else :
i = ...
return rendu
21_NSI_23⚓︎
def fusion(L1,L2):
n1 = len(L1)
n2 = len(L2)
L12 = [0]*(n1+n2)
i1 = 0
i2 = 0
i = 0
while i1 < n1 and ... :
if L1[i1] < L2[i2]:
L12[i] = ...
i1 = ...
else:
L12[i] = L2[i2]
i2 = ...
i += 1
while i1 < n1:
L12[i] = ...
i1 = i1 + 1
i = ...
while i2 < n2:
L12[i] = ...
i2 = i2 + 1
i = ...
return L12
21_NSI_24⚓︎
class AdresseIP:
def __init__(self, adresse):
self.adresse = ...
def liste_octet(self):
"""renvoie une liste de nombres entiers,
la liste des octets de l'adresse IP"""
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"""
return ... or ...
def adresse_suivante(self):
"""renvoie un objet de AdresseIP avec l'adresse
IP qui suit l’adresse self
si elle existe et False sinon"""
if ... < 254:
octet_nouveau = ... + ...
return AdresseIP('192.168.0.' + ...)
else:
return False
21_NSI_25⚓︎
def propager(M, i, j, val):
if M[i][j]== ...:
return
M[i][j]=val
# l'élément en haut fait partie de la composante
if ((i-1) >= 0 and M[i-1][j] == ...):
propager(M, i-1, j, val)
# l'élément en bas fait partie de la composante
if ((...) < len(M) and M[i+1][j] == 1):
propager(M, ..., j, val)
# l'élément à gauche fait partie de la composante
if ((...) >= 0 and M[i][j-1] == 1):
propager(M, i, ..., val)
# l'élément à droite fait partie de la composante
if ((...) < len(M) and M[i][j+1] == 1):
propager(M, i, ..., val)
21_NSI_26⚓︎
def nbLig(image):
'''renvoie le nombre de lignes de l'image'''
return ...
def nbCol(image):
'''renvoie la largeur de l'image'''
return ...
def negatif(image):
'''renvoie le négatif de l'image sous la forme
d'une liste de listes'''
L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))] # on créé une image de 0 aux mêmes dimensions que le paramètre image
for i in range(len(image)):
for j in range(...):
L[i][j] = ...
return L
def binaire(image, seuil):
'''renvoie une image binarisée de l'image sous la forme
d'une liste de listes contenant des 0 si la valeur
du pixel est strictement inférieure au seuil
et 1 sinon'''
L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))] # on crée une image de 0 aux mêmes dimensions que le paramètre image
for i in range(len(image)):
for j in range(...):
if L[i][j] < ... :
L[i][j] = ...
else:
L[i][j] = ...
return L
21_NSI_27⚓︎
coeur = [[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], \
[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], \
[0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]
def affiche(dessin):
''' affichage d'une grille : les 1 sont représentés par
des "*" , les 0 par deux espaces " " '''
for ligne in dessin:
for col in ligne:
if col == 1:
print(" *",end="")
else:
print(" ",end="")
print()
def zoomListe(liste_depart,k):
'''renvoie une liste contenant k fois chaque
élément de liste_depart'''
liste_zoom = ...
for elt in ... :
for i in range(k):
...
return liste_zoom
def zoomDessin(grille,k):
'''renvoie une grille où les lignes sont zoomées k fois
ET répétées k fois'''
grille_zoom=[]
for elt in grille:
liste_zoom = ...
for i in range(k):
... .append(...)
return grille_zoom
21_NSI_28⚓︎
def tri_iteratif(tab):
for k in range( ... , 0, -1):
imax = ...
for i in range(0 , ... ):
if tab[i] > ... :
imax = i
if tab[max] > ... :
... , tab[imax] = tab[imax] , ...
return tab
21_NSI_29⚓︎
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 est_parfait(mot) :
#mot est une chaîne de caractères (en lettres majuscules)
code_c = ""
code_a = ???
for c in mot :
code_c = code_c + ???
code_a = ???
code_c = int(code_c)
if ??? :
mot_est_parfait = True
else :
mot_est_parfait = False
return [code_a, code_c, mot_est_parfait]
21_NSI_30⚓︎
def chercher(T,n,i,j):
if i < 0 or ??? :
print("Erreur")
return None
if i > j :
return None
m = (i+j) // ???
if T[m] < ??? :
return chercher(T, n, ??? , ???)
elif ??? :
return chercher(T, n, ??? , ??? )
else :
return ???