Correction EP 2023
01_01.py : test si tri croissant 01_02.py : dépouillement votes 02_01.py : recherche maximum 02_02.py : pile des positifs 03_01.py : moyenne pondérée 03_02.py : zoom image binaire 04_01.py : test doublons 04_02.py : grilles démineur 05_01.py : série de lancer de dé6 : test si plusieurs 6 05_02.py : image niveaux gris : négatif + seuil 06_01.py : recherche dernière occurrence 06_02.py : plus courte distance à des points 07_01.py : fusion de tableaux triés 07_02.py : conversion nombre romain vers décimal 08_01.py : réseau social TipTop et maximum de « like » 08_02.py : simulation d'une calculatrice HP à saisie RPN 09_01.py : multiplier par additions/soustractions 09_02.py : recherche dans un sous-tableau trié 10_01.py : recherche maximum 10_02.py : test correction parenthésage par empilements/dépilements 11_01.py : conversion nombre binaire vers décimal 11_02.py : tri par insertion 12_01.py : insertion dans ABR 12_02.py : mise en boîtes gloutonne 13_01.py : occurrences nombre 13_02.py : rendu monnaie glouton 14_01.py : recherche 1ère occurrence 14_02.py : insertion dans tableau trié 15_01.py : recherche minimum de températures 15_02.py : test nombre palindrome 16_01.py : indices valeurs inférieurs égales et supérieures 16_02.py : moyenne pondérée 17_01.py : moyenne pondérée 17_02.py : triangle de Pascal 18_01.py : recherche maximum 18_02.py : rupture de gènes sur chromosome 19_01.py : recherche par dichotomie 19_02.py : code César 20_01.py : addition de dictionnaires 20_02.py : jeu sur piste carrée 21_01.py : codage par différence 21_02.py : conversion arbre de calcul vers expression 22_01.py : puissances d'un nombre 22_02.py : test mot parfait 23_01.py : recherche animaux d'un enclos 23_02.py : intrus parmi triplets 24_01.py : occurrences des caractères dans une phrase 24_02.py : fusion de listes triées 25_01.py : indices des valeurs 25_02.py : insertion dans ABR 26_01.py : multiplier par additions/soustractions 26_02.py : test présence valeur par dichotomie 27_01.py : recherche minimum 27_02.py : tri tableau de bits 28_01.py : moyenne arithmétique 28_02.py : test présence valeur par dichotomie 29_01.py : taille et hauteur d'un arbre 29_02.py : insertion dans liste triée 30_01.py : moyenne arithmétique 30_02.py : conversion décimal vers binaire 31_01.py : occurrences valeur 31_02.py : conversion décimal vers binaire 32_01.py : recherche minimum et maximum 32_02.py : paquet de cartes 33_01.py : taille d'un arbre 33_02.py : tri par insertion 34_01.py : moyenne arithmétique 34_02.py : tri tableau de bits 35_01.py : ou exclusif de tableaux 35_02.py : test carré semimagique 36_01.py : couples consécutifs d'un tableau 36_02.py : remplissage de forme sur image 37_01.py : recherche dernière occurrence 37_02.py : adresses IPv4 : test réservée + prochaine adresse 38_01.py : test de correspondance avec un mot à trous 38_02.py : test cycle de messages 39_01.py : suite de Fibonacci 39_02.py : Panthéon de NSI 40_01.py : comptage des mots d'une phrase 40_02.py : insertion dans ABR 41_01.py : occurrences d'un caractère dans une phrase 41_02.py : rendu monnaie glouton 42_01.py : tri par sélection 42_02.py : jeu du « plus ou moins » 43_01.py : conversion décimal vers binaire 43_02.py : tri à bulles 44_01.py : inversion d'une chaîne 44_02.py : crible d'Ératosthène 45_01.py : tri des notes d'une évaluation 45_02.py : conversions décimal-binairedef verifie(tab):
n=len(tab)
if n==1:
return True
for i in range(n-1):
if tab[i]>tab[i+1]:
return False
return True
Sujet 2 :
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 ...Correction :
urne = ['A', 'A', 'A','B', 'C', 'B', 'C','B', 'C', 'B'] def depouille(urne): resultat = {} for bulletin in urne: if bulletin in resultat: resultat[bulletin] = resultat[bulletin] + 1 else: resultat[bulletin]=1 return resultat def vainqueur(election): vainqueur = '' #cette variable ne sert à rien nmax = 0 for candidat in election: if election[candidat] > nmax : nmax = election[candidat] vainqueur = candidat #cette ligne ne sert à rien ! liste_finale = [nom for nom in election if election[nom] == nmax] return liste_finale
def indices_maxi(tab):
t_maxi = []
maxi = tab[0]
n = len(tab)
for i in range(1,n):
if tab[i]>maxi:
maxi = tab[i]
for i in range(n):
if tab[i] == maxi:
t_maxi.append(i)
return maxi, t_maxiSujet 2 :
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_1Correction :
def positif(pile): pile_1 = list(pile) pile_2 = [] while pile_1 != []: x = pile_1.pop() if x >= 0: pile_2.append(x) while pile_2 != []: x = pile_2.pop() pile_1.append(x) return pile_1
def moyenne(tab):
s_valeur = 0
s_coef = 0
for v in tab:
s_valeur = s_valeur + v[0]*v[1]
s_coef = s_coef + v[1]
if s_coef == 0:
return None
else :
return s_valeur/s_coefSujet 2 :
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): for ligne in dessin: for col in ligne: if col == 1: print(" *", end= "") else: print(" ", end= "") print() def zoomListe(liste_depart, k): liste_zoom = ... for elt in ... : for i in range(k): ... return liste_zoom def zoomDessin(grille, k): grille_zoom = [] for elt in grille: liste_zoom = ... for i in range(k): ... .append(...) return grille_zoomCorrection :
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): for ligne in dessin: for col in ligne: if col == 1: print(" *", end= "") else: print(" ", end= "") print() def zoomListe(liste_depart, k): liste_zoom = [] for elt in liste_depart: for i in range(k): liste_zoom.append(elt) return liste_zoom def zoomDessin(grille, k): grille_zoom = [] for elt in grille: liste_zoom = zoomListe(elt, k) for i in range(k): grille_zoom.append(liste_zoom) return grille_zoom
def a_doublon(tab):
n = len(tab)
if n < 2 :
return False
for i in range(n-1):
if tab[i] == tab[i+1]:
return True
return FalseSujet 2 :
def voisinage(n, ligne, colonne): 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): voisins = ... for l, c in voisins: if grille[l][c] != ...: ... def genere_grille(bombes): n = len(bombes) grille = [[0 for colonne in range(n)] for ligne in range(n)] for ligne, colonne in bombes: grille[ligne][colonne] = ... ... return grilleCorrection :
def voisinage(n, ligne, colonne): 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): voisins = voisinage(len(grille), ligne, colonne) for l, c in voisins: if grille[l][c] != -1: grille[l][c] = grille[l][c] + 1 def genere_grille(bombes): n = len(bombes) grille = [[0 for colonne in range(n)] for ligne in range(n)] for ligne, colonne in bombes: grille[ligne][colonne] = -1 incremente_voisins(grille, ligne, colonne) return grille
from random import randint
def lancer(n):
t = []
for _ in range(n):
t.append(randint(1,6))
return t
def paire_6(tab) :
n = 0
for v in tab:
if v == 6:
n = n + 1
return n >= 2Sujet 2 :
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 LCorrection :
img=[[20, 34, 254, 145, 6], [23, 124, 237, 225, 69], [197, 174, 207, 25, 87], [255, 0, 24, 197, 189]] def nbLig(image): return len(image) def nbCol(image): return len(image[0]) def negatif(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(nbCol(image)): L[i][j] = 255 - image[i][j] return L def binaire(image, seuil): L = [[0 for k in range(nbCol(image))] for i in range(nbLig(image))] for i in range(nbLig(image)): for j in range(nbCol(image)): if image[i][j] < seuil : L[i][j] = 0 else: L[i][j] = 1 return L
def recherche(tab,n):
indice = len(tab)
i = 0
for i in range(len(tab)):
if tab[i] == n:
indice = i
return indice
Sujet 2 :
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 pointCorrection :
from math import sqrt def distance(point1, point2): return sqrt((point1[0]-point2[0])**2 + (point1[1]-point2[1])**2) def plus_courte_distance(tab, depart): point = tab[0] min_dist = distance(point, depart) for i in range (1, len(tab)): if distance(tab[i], depart) < min_dist : point = tab[i] min_dist = distance(tab[i], depart) return point
def fusion(tab1, tab2):
n1 = len(tab1)
n2 = len(tab2)
i1 = 0
i2 = 0
tab=[]
while i1 < n1 and i2 < n2:
if tab1[i1] > tab2[i2]:
tab.append(tab2[i2])
i2 = i2 + 1
else :
tab.append(tab1[i1])
i1 = i1 + 1
while i1 < n1 :
tab.append(tab1[i1])
i1 = i1 + 1
while i2 < n2 :
tab.append(tab2[i2])
i2 = i2 + 1
return tab
Sujet 2 :
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 ...Correction :
romains = {"I":1, "V":5, "X":10, "L":50, "C":100, "D":500, "M":1000} def traduire_romain(nombre) : if len(nombre) == 1: return romains[nombre[0]] elif romains[nombre[0]] >= romains[nombre[1]] : return romains[nombre[0]] + traduire_romain(nombre[1:]) else: return traduire_romain(nombre[1:]) - romains[nombre[0]]
def max_dico(dico):
maxi_v = 0
maxi_n = ""
for nom, val in dico.items():
if val > maxi_v:
maxi_v = val
maxi_n = nom
return maxi_n, maxi_v
Sujet 2 :
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 ...Correction :
class Pile: def __init__(self): self.contenu = [] def est_vide(self): return self.contenu == [] def empiler(self, v): self.contenu.append(v) def depiler(self): if not self.est_vide(): return self.contenu.pop() def eval_expression(tab): p = Pile() for element in tab: if element != '+' and element != '*': p.empiler(element) else: if element == '+': resultat = p.depiler() + p.depiler() else: resultat = p.depiler() * p.depiler() p.empiler(resultat) return p.depiler()
def multiplication(n1,n2):
s=0
if n1==0 or n2==0:
return 0
if n1<0:
return -multiplication(-n1,n2)
if n2<0:
return -multiplication(n1,-n2)
for i in range(n2):
s = s+n1
return sSujet 2 :
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 ...Correction :
def chercher(tab, n, i, j): if i < 0 or j > len(tab): return None elif i > j: return None m = (i + j) // 2 if tab[m] < n: return chercher(tab, n, m+1, j) elif tab[m] > n: return chercher(tab, n, i, m-1) else: return m
def maxliste(tab):
maxi = tab[0]
for v in tab:
if v > maxi:
maxi = v
return maxiSujet 2 :
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()Correction :
class Pile: def __init__(self): self.valeurs = [] def est_vide(self): return self.valeurs == [] def empiler(self, c): self.valeurs.append(c) def depiler(self): if self.est_vide() == False: self.valeurs.pop() def parenthesage(ch): p = Pile() for c in ch: if c == "(": p.empiler(c) elif c == ")": if p.est_vide(): return False else: p.depiler() return p.est_vide()
def convertir(tab):
n = len(tab)
s = 0
for i in range(n):
s = s + tab[i]*2**(n-i-1)
return s
Sujet 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] = ...Correction :
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[i] j = i while j > 0 and valeur_insertion < tab[j-1]: tab[j] = tab[j-1] j = j - 1 tab[j] = valeur_insertion
class ABR:
def __init__(self, g0, v0, d0):
self.gauche = g0
self.cle = v0
self.droit = d0
def __repr__(self):
return f"({self.gauche}, {self.cle}, {self.droit})"
n0 = ABR(None,0,None)
n3 = ABR(None,3,None)
n2 = ABR(None,2,n3)
abr1 = ABR(n0,1,n2)
def ajoute(cle, a):
if a is None:
return ABR(None, cle, None)
elif cle == a.cle:
return a
elif cle < a.cle:
return ABR(ajoute(cle, a.gauche), a.cle, a.droit)
else:
return ABR(a.gauche, a.cle, ajoute(cle, a.droit))Sujet 2 :
#------------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 ...Correction :
def empaqueter(liste_masses, c): n = len(liste_masses) nb_boites = 0 boites = [0]*n for masse in liste_masses : i=0 while i <= nb_boites and boites[i] + masse > c: i = i + 1 if i == nb_boites + 1: nb_boites = nb_boites + 1 boites[i] = boites[i] + masse return nb_boites + 1
def recherche(a, tab):
c = 0
for v in tab:
if v==a:
c=c+1
return cSujet 2 :
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 renduCorrection :
pieces = [1, 2, 5, 10, 20, 50, 100, 200] def rendu_monnaie(somme_due, somme_versee): rendu = [] a_rendre = somme_versee - somme_due i = len(pieces) - 1 while a_rendre > 0 : if pieces[i] <= a_rendre : rendu.append(pieces[i]) a_rendre = a_rendre - pieces[i] else : i = i - 1 return rendu
def recherche(elt, tab):
for i in range(len(tab)):
if tab[i]==elt:
return i
return -1Sujet 2 :
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 lCorrection :
def insere(a, tab): l = list(tab) l.append(a) i = len(l) - 2 while i >= 0 and a < tab[i] : l[i+1] = l[i] l[i] = a i = i - 1 return l
t_moy = [14.9, 13.3, 13.1, 12.5, 13.0, 13.6, 13.7]
annees = [2013, 2014, 2015, 2016, 2017, 2018, 2019]
def mini(releve, date):
m = releve[0]
indice = 0
for i in range(1, len(releve)):
if releve[i]<m:
m = releve[i]
indice = i
return m, date[indice]
Sujet 2 :
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)Correction :
def inverse_chaine(chaine): result = "" for caractere in chaine: result = caractere + result return result def est_palindrome(chaine): inverse = inverse_chaine(chaine) return inverse == chaine def est_nbre_palindrome(nbre): chaine = str(nbre) return est_palindrome(chaine)
def recherche_indices_classement(elt, tab):
l_eg = []
l_sup = []
l_inf = []
for i in range(len(tab)):
if tab[i]>elt:
l_sup.append(i)
elif tab[i]<elt:
l_inf.append(i)
else:
l_eg.append(i)
return l_inf, l_eg, l_supSujet 2 :
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 -1Correction :
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 dico_result: notes = dico_result[nom] total_points = 0 total_coefficients = 0 for valeurs in notes.values(): note, coefficient = valeurs total_points = total_points + note * coefficient total_coefficients = total_coefficients + coefficient return round( total_points / total_coefficients, 1 ) else: return -1
def moyenne(liste_notes):
s_n = 0
s_c = 0
for v in liste_notes:
s_n = s_n + v[0]*v[1]
s_c = s_c + v[1]
return s_n / s_c
Sujet 2 :
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 triangleCorrection :
def pascal(n): triangle= [[1]] for k in range(1, n+1): ligne_k = [1] for i in range(1,k): ligne_k.append(triangle[k-1][i-1]+triangle[k-1][i]) ligne_k.append(1) triangle.append(ligne_k) return triangle
def max_et_indice(tab):
"""
Prend en paramètre une liste non vide tab de nombres entiers
et renvoie la valeur du plus grand élément de cette liste
ainsi que l’indice de sa première apparition dans cette liste.
"""
index_m = 0
maxi = tab[0]
for i in range(1, len(tab)):
if tab[i] > maxi:
index_m = i
maxi = tab[i]
return maxi, index_m
assert max_et_indice([1, 5, 6, 9, 1, 2, 3, 7, 9, 8]) == (9, 3)
assert max_et_indice([-2]) == (-2, 0)
assert max_et_indice([-1, -1, 3, 3, 3]) == (3, 2)
assert max_et_indice([1, 1, 1, 1]) == (1, 0)
Sujet 2 :
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 nbCorrection :
def est_un_ordre(tab): for i in range(1, len(tab)+1): if i not in tab : return False return True def nombre_points_rupture(ordre): assert est_un_ordre(ordre) n = len(ordre) nb = 0 if ordre[0] != 1: nb = nb + 1 i = 0 while i < len(ordre)-1: if (ordre[i+1] - ordre[i]) not in [-1, 1]: nb = nb + 1 i = i + 1 if ordre[n-1] != n: nb = nb + 1 return nb
def recherche (tab, n):
deb = 0
fin = len(tab)-1
indice = -1
while deb <= fin and indice == -1:
mil = (deb+fin)//2
if tab[mil] == n:
indice = mil
elif n > tab[mil]:
deb = mil + 1
else :
fin = mil - 1
return indice
Sujet 2 :
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 resultatCorrection :
ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' def position_alphabet(lettre): return ord(lettre) - ord('A') def cesar(message, decalage): resultat = '' for c in message: if 'A' <= c and c <= 'Z': indice = (position_alphabet(c) + decalage) % 26 resultat = resultat + ALPHABET[indice] else: resultat = resultat + c return resultat
def ajoute_dictionnaires(d1, d2):
d = {}
for k in d1:
if k in d2 :
d[k] = d1[k] + d2[k]
else :
d[k] = d1[k]
for k in d2 :
if k not in d:
d[k] = d2[k]
return dSujet 2 :
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 nCorrection :
from random import randint def nbre_coups(): n = 0 cases_vues = [0] case_en_cours = 0 nbre_cases = 12 while len(cases_vues) < nbre_cases : x = randint(1, 6) case_en_cours = (case_en_cours + x) % nbre_cases if case_en_cours not in cases_vues : cases_vues.append(case_en_cours) n = n + 1 return n
def delta(liste):
tab = [liste[0]]
for i in range(1, len(liste)):
tab.append(liste[i]-liste[i-1])
return tab
Sujet 2 :
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 sCorrection :
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): 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(e.gauche) s = s + str(e.valeur) if e.gauche is not None: s = s + expression_infixe(e.droit) + ')' return s 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)))
def liste_puissances(a, n):
tab = [a]
for _ in range(2, n+1):
r = tab[-1]*a
tab.append(r)
return tab
def liste_puissances_borne(a, borne):
if borne <= a:
return []
tab = [a]
c = True
while c:
r = tab[-1]*a
if r < borne:
tab.append(r)
else :
c = False
return tab
Sujet 2 :
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_parfaitCorrection :
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): code_concatene = "" code_additionne = 0 for c in mot: code_concatene = code_concatene + str(dico[c]) code_additionne = code_additionne + dico[c] code_concatene = int(code_concatene) if code_concatene % code_additionne == 0 : mot_est_parfait = True else: mot_est_parfait = False return code_additionne, code_concatene, mot_est_parfait
def selection_enclos(table_animaux, num_enclos):
tab = []
for d in table_animaux:
if d['enclos'] == num_enclos:
tab.append(d)
return tab
Sujet 2 :
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 ...Correction :
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): if g == d: return tab[g] else: nombre_de_triplets = (d - g)// 3 indice = g + 3 * (nombre_de_triplets // 2) if tab[indice]==tab[indice+1] : return trouver_intrus(tab,indice+3,d) else: return trouver_intrus(tab,g,indice)
def nbr_occurrences(chaine):
d = {}
for c in chaine:
if c in d:
d[c] = d[c]+1
else :
d[c] = 1
return dSujet 2 :
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 lst12Correction :
def fusion(lst1, lst2): n1 = len(lst1) n2 = len(lst2) lst12 = [0] * (n1 + n2) i1 = 0 i2 = 0 i=0 while i1 < n1 and i2 < n2 : if lst1[i1] < lst2[i2]: lst12[i] = lst1[i1] i1 = i1 + 1 else: lst12[i] = lst2[i2] i2 = i2 + 1 i += 1 while i1 < n1: lst12[i] = lst1[i1] i1 = i1 + 1 i = i + 1 while i2 < n2: lst12[i] = lst2[i2] i2 = i2 + 1 i = i + 1 return lst12
def enumere(L):
d = {}
for i in range(len(L)):
if L[i] in d :
d[L[i]].append(i)
else :
d[L[i]]=[i]
return d
Sujet 2 :
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)Correction :
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): if cle < arbre.v : if arbre.fg != None: insere(arbre.fg, cle) else: arbre.fg = Arbre(cle) else: if arbre.fd != None: insere(arbre.fd, cle) else: arbre.fd = Arbre(cle) Abr = Arbre(5) a1 = Arbre(2) a2 = Arbre(3) a3 = Arbre(7) Abr.fg = a1 Abr.fd = a3 Abr.fg.fd = a2 insere(Abr, 1) insere(Abr, 4) insere(Abr, 6) insere(Abr, 8) print(parcours(Abr, []))
def multiplication(n1,n2):
s=0
if n1==0 or n2==0:
return 0
if n1<0:
return -multiplication(-n1,n2)
if n2<0:
return -multiplication(n1,-n2)
for _ in range(n2):
s = s+n1
return s
Sujet 2 :
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 ...Correction :
def dichotomie(tab, x): debut = 0 fin = len(tab) - 1 while debut <= fin: m = (debut + fin) // 2 if x == tab[m]: return True if x > tab[m]: debut = m + 1 else: fin = m - 1 return False
def recherche_min(tab):
indice_mini = 0
mini = tab[0]
for i in range(1, len(tab)):
if tab[i] < mini:
indice_mini = i
mini = tab[i]
return indice_miniSujet 2 :
def separe(tab): gauche = 0 droite = ... while gauche < droite : if tab[gauche] == 0 : gauche = ... else : tab[gauche], tab[droite] = ... droite = ... return tabCorrection :
def separe(tab): gauche = 0 droite = len(tab) - 1 while gauche < droite : if tab[gauche] == 0 : gauche = gauche + 1 else : tab[gauche], tab[droite] = tab[droite], tab[gauche] droite = droite - 1 return tab
def moyenne(tab):
s = 0
for v in tab :
s = s + v
return s/len(tab)
assert moyenne([1]) == 1
assert moyenne([1, 2, 3, 4, 5, 6, 7]) == 4
assert moyenne([1, 2]) == 1.5Sujet 2 :
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 ...Correction :
def dichotomie(tab, x): if len(tab) == 0: return False, 1 if (x < tab[0]) or (x > tab[len(tab)-1]): return False, 2 debut = 0 fin = len(tab) - 1 while debut <= fin: m = (debut + fin) // 2 if x == tab[m]: return True if x > tab[m]: debut = m + 1 else: fin = m - 1 return False, 3
class Arbre:
def __init__(self, etiquette):
self.v = etiquette
self.fg = None
self.fd = None
def taille(a):
if a == None:
return 0
return 1+taille(a.fg)+taille(a.fd)
def hauteur(a):
if a == None:
return 0
return 1+max(hauteur(a.fg), hauteur(a.fd))
abr = Arbre(0)
a1 = Arbre(1)
a3 = Arbre(3)
a2 = Arbre(2)
a4 = Arbre(4)
a5 = Arbre(5)
a6 = Arbre(6)
a4.fd = a6
a2.fg = a4
a2.fd = a5
a1.fg = a3
abr.fg = a1
abr.fd = a2
Sujet 2 :
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 LCorrection :
def ajoute(indice, element, liste): nbre_elts = len(liste) L = [0 for i in range(nbre_elts + 1)] if indice < nbre_elts: for i in range(indice): L[i] = liste[i] L[indice] = element for i in range(indice + 1, nbre_elts + 1): L[i] = liste[i-1] else: for i in range(nbre_elts): L[i] = liste[i] L[nbre_elts] = element return L
def moyenne (tab):
s = 0
for v in tab:
s = s + v
return s / len(tab)
Sujet 2 :
def binaire(a): bin_a = ... a = a // 2 while a ... : bin_a = ... + bin_a a = ... return bin_aCorrection :
def binaire(a): bin_a = str(a % 2) a = a // 2 while a > 0 : bin_a = str(a % 2) + bin_a a = a // 2 return bin_a
def nb_repetitions(elt, tab):
c = 0
for v in tab:
if v == elt:
c = c + 1
return c
Sujet 2 :
def binaire(a): bin_a = str(...) a = a // 2 while a ... : bin_a = ...(a%2) + ... a = ... return bin_aCorrection :
def binaire(a): bin_a = str(a%2) a = a // 2 while a > 0 : bin_a = str(a%2) + bin_a a = a // 2 return bin_a
def min_et_max(tab):
mini = tab[0]
maxi = tab[0]
for v in tab:
if v > maxi:
maxi = v
if v < mini:
mini = v
return {'min':mini, 'max': maxi}
Sujet 2 :
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éterCorrection :
class Carte: def __init__(self, c, v): self.couleur = c self.valeur = v def get_valeur(self): valeurs = ['As','2', '3', '4', '5', '6', '7', '8', '9', '10', 'Valet', 'Dame', 'Roi'] return valeurs[self.valeur - 1] def get_couleur(self): couleurs = ['pique', 'coeur', 'carreau', 'trèfle'] return couleurs[self.couleur - 1] class Paquet_de_cartes: def __init__(self): self.paquet=[] for c in range (1,5): for v in range(1,14): self.paquet.append(Carte(c,v)) def get_carte(self, pos): assert pos < 52 and pos > -1, "paramètre pos invalide" return self.paquet[pos]
def taille(arbre, lettre):
if lettre == '':
return 0
return 1 + taille(arbre, arbre[lettre][0]) + taille(arbre, arbre[lettre][1])
Sujet 2 :
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] , ...Correction :
def tri_selection(tab): N = len(tab) for k in range(N-1): imin = k for i in range(k+1 , N): if tab[i] < tab[imin] : imin = i tab[k] , tab[imin] = tab[imin] , tab[k]
def moyenne(tab):
assert len(tab) != 0, "aucune note"
s = 0
for v in tab :
s = s + v
return s/len(tab)
Sujet 2 :
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= ... ...Correction :
def tri(tab): i= 0 j= len(tab) - 1 while i != j : if tab[i] == 0: i= i + 1 else : valeur = tab[j] tab[j] = tab[i] tab[i] = valeur j= j - 1 return tab
def ou_exclusif(t1, t2):
n = len(t1)
t = [0]*n
for i in range(n):
if t1[i] == t2[i]:
t[i] = 0
else :
t[i] = 1
return t
Sujet 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 ...Correction :
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): for i in range(self.ordre): print(self.tableau[i]) def somme_ligne(self, i): somme = 0 for j in range(self.ordre): somme = somme + self.tableau[i][j] return somme def somme_col(self, 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) for i in range(1, self.ordre): if self.somme_ligne(i) != s: return False for j in range(self.ordre): if self.somme_col(j) != s: return False return True
def couples_consecutifs(tab):
"""
prend en paramètre une liste de nombres entiers tab non vide, et qui renvoie la liste (éventuellement vide) des couples d'entiers consécutifs successifs qu'il peut y avoir dans tab.
"""
t = []
for i in range(len(tab)-1):
if tab[i+1] - tab[i] == 1:
t.append((tab[i], tab[i+1]))
return t
assert couples_consecutifs([1, 4, 3, 5]) == []
assert couples_consecutifs([1, 4, 5, 3]) == [(4, 5)]
assert couples_consecutifs([1, 1, 2, 4]) == [(1, 2)]
assert couples_consecutifs([7, 1, 2, 5, 3, 4]) == [(1, 2), (3, 4)]
assert couples_consecutifs ([5, 1, 2, 3, 8, -5, -4, 7]) == [(1, 2), (2, 3), (-5, -4)]
Sujet 2 :
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(..., ..., ..., ...)Correction :
def propager(M, i, j, val): if M[i][j] == 1: M[i][j] = val if i-1 >= 0 and M[i-1][j] == 1: propager(M, i-1, j, val) if i+1 < len(M) and M[i+1][j] == 1: propager(M, i+1, j, val) if j-1 >=0 and M[i][j-1] == 1: propager(M, i, j-1, val) if j+1 < len(M[i]) and M[i][j+1] == 1: propager(M, i, j+1, val)
def recherche(elt, tab):
indice = -1
for i in range(len(tab)):
if tab[i] == elt:
indice = i
return indiceSujet 2 :
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 FalseCorrection :
class AdresseIP: def __init__(self, adresse): self.adresse = adresse def liste_octet(self): return [int(i) for i in self.adresse.split(".")] def est_reservee(self): return self.adresse == '192.168.0.0' or self.adresse == '192.168.0.255' def adresse_suivante(self): if self.liste_octet()[3] < 254: octet_nouveau = self.liste_octet()[3] + 1 return AdresseIP('192.168.0.' + str(octet_nouveau)) else: return False adresse1 = AdresseIP('192.168.0.1') adresse2 = AdresseIP('192.168.0.2') adresse3 = AdresseIP('192.168.0.0')
def correspond(mot, mot_a_trous):
n1 = len(mot)
n2 = len(mot_a_trous)
if n1 != n2:
return False
for i in range(n1):
if mot[i] != mot_a_trous[i] and mot_a_trous[i] != '*':
return False
return TrueSujet 2 :
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 == ...Correction :
def est_cyclique(plan): expediteur = 'A' destinataire = plan[expediteur] nb_destinaires = 1 while destinataire != expediteur: destinataire = plan[destinataire] nb_destinaires += 1 return nb_destinaires == len(plan)
def fibonacci(n):
tab = [None]*(n+1)
tab[1] = 1
tab[2] = 1
for i in range(3, n+1):
tab[i] = tab[i-1] + tab[i-2]
return tab[n]
Sujet 2 :
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]Correction :
def pantheon(eleves, notes): note_maxi = 0 meilleurs_eleves = [] for i in range(len(eleves)) : if notes[i] == note_maxi : meilleurs_eleves.append(eleves[i]) elif notes[i] > note_maxi: note_maxi = notes[i] meilleurs_eleves = [eleves[i]] 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]
def nombre_de_mots(phrase):
nb = 0
id_der = len(phrase)-1
for c in phrase:
if c == " ":
nb = nb + 1
if phrase[id_der] == "?" or phrase[id_der] == "!":
return nb
else :
return nb+1Sujet 2 :
class Noeud: def __init__(self, valeur): '''Méthode constructeur pour la classe Noeud. Paramètre d'entrée : valeur (int)''' 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 le sous-arbre droit est non vide Aucun paramètre en entrée''' return (self.droit is not None) def gaucheExiste(self): '''Méthode renvoyant True si le sous-arbre gauche est non vide 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 recommence le test initial ... else: # on crée un fils gauche self.gauche = ... elif cle > ...: # on insère à droite if ...: # on descend à droite et on recommence le test initial ... else: # on crée un fils droit ... = Noeud(cle)Correction :
class Noeud: def __init__(self, valeur): self.valeur = valeur self.gauche = None self.droit = None def getValeur(self): return self.valeur def droitExiste(self): return (self.droit is not None) def gaucheExiste(self): return (self.gauche is not None) def inserer(self, cle): if cle < self.valeur : if self.gaucheExiste(): self.gauche.inserer(cle) else: self.gauche = Noeud(cle) elif cle > self.valeur: if self.droitExiste(): self.droit.inserer(cle) else: self.droit = Noeud(cle)
def recherche(caractere, chaine):
n = 0
for c in chaine:
if c == caractere:
n = n + 1
return n
Sujet 2 :
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, ...)Correction :
valeurs = [100,50,20,10,5,2,1] def rendu_glouton(a_rendre, rang): if a_rendre == 0: return [] v = valeurs[rang] if v <= a_rendre : return [v] + rendu_glouton(a_rendre - v, rang) else : return rendu_glouton(a_rendre, rang+1)
def tri_selection(tab):
n = len(tab)
for i in range(n-1):
min_i = i
for j in range(i+1, n):
if tab[j] < tab[min_i]:
min_i = j
tab[i], tab[min_i] = tab[min_i], tab[i]
return tabSujet 2 :
#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 ", ...)Correction :
from random import randint def plus_ou_moins(): nb_mystere = randint(1, 99) nb_test = int(input("Proposez un nombre entre 1 et 99 : ")) compteur = 1 while nb_mystere != nb_test and compteur < 10: 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 etait ", nb_mystere) print("Nombre d'essais: ", compteur) else: print("Perdu ! Le nombre etait ", nb_mystere)
def ecriture_binaire_entier_positif(n):
tab = [n%2]
n = n // 2
while n > 0:
tab.append(n%2)
n = n // 2
tab.reverse()
return tab
Sujet 2 :
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 TCorrection :
def tri_bulles(T): n = len(T) for i in range(len(T)-1,0,-1): for j in range(i): if T[j] > T[j+1]: temp = T[j] T[j] = T[j+1] T[j+1] = temp return T
def renverse(mot):
chaine = ''
for c in mot:
chaine = c + chaine
return chaineSujet 2 :
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]Correction :
def crible(n): premiers = [] tab = [True] * n tab[0], tab[1] = False, False for i in range(2, n): if tab[i] == True: premiers.append(i) for multiple in range(2 * i, n, i): tab[multiple] = False return premiers assert crible(40) == [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37]
def rangement_valeurs(notes_eval):
tab = [0]*11
for n in notes_eval:
tab[n] = tab[n] + 1
return tab
def notes_triees(effectifs_notes):
tab = []
for i in range(len(effectifs_notes)):
for _ in range(effectifs_notes[i]):
tab.append(i)
return tab
Sujet 2 :
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]) + ...Correction :
def dec_to_bin (nb_dec): q, r = nb_dec // 2, nb_dec % 2 if q == 0: return str(r) else: return dec_to_bin(q) + str(r) def bin_to_dec(nb_bin): if nb_bin == '0': return 0 elif nb_bin == '1': return 1 else: if nb_bin[-1] == '0': bit_droit = 0 else: bit_droit = 1 return 2 * bin_to_dec(nb_bin[:-1]) + bit_droit