Correction EP 2022


PDF

01_01.py : Recherche d'occurrences (1er)

# 2022 Sujet 1 ex 1
def recherche(caractere, mot):
    somme = 0
    for lettre in mot:
        if lettre == caractere:
            somme += 1
    return somme

# test
print(recherche('e', "sciences"))

print(recherche('i',"mississippi"))
print(recherche('a',"mississippi"))

PDF

01_02.py : Recursif (Tle) : Rendu de monnaie

Sujet 2 :
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, ...)

Correction :
# 2022 Sujet 1 ex 2
pieces = [100,50,20,10,5,2,1]

def rendu_glouton(arendre, solution=[], i=0):
    if arendre == 0:
        return solution
    p = pieces[i]
    if p <= arendre :
        solution.append(p)
        return rendu_glouton(arendre - p, solution,i)
    else :
        return rendu_glouton(arendre, solution, i+1)

print(rendu_glouton(68,[],0))
print(rendu_glouton(291,[],0))

PDF

02_01.py : Calcul d'une moyenne pondérée avec une liste de tuples (1er)

# 2022 Sujet 2 ex 1
def moyenne(tab):
    somme_notes = 0
    somme_coeffs = 0
    for devoir in tab:
        note = devoir[0]
        coeff = devoir[1]
        somme_notes += note * coeff
        somme_coeffs += coeff
    return somme_notes / somme_coeffs

print(moyenne([(15,2),(9,1),(12,3)]))

PDF

02_02.py : Listes de Listes : Triangle de Pascal (1er)

Sujet 2 :
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

Correction :
# 2022 Sujet 2 ex 2
def pascal(n):
    C = [[1]]
    for k in range(1,n+1):
        Ck = [1]
        for i in range(1,k):
            Ck.append(C[k-1][i-1]+C[k-1][i] )
        Ck.append(1)
        C.append(Ck)
    return C

print(pascal(4))

print(pascal(5))

PDF

03_01.py : Codage par différence (1er)

# 2022 Sujet 3 ex 1
def delta(tab):
    diff = [tab[0]]
    for i in range(1, len(tab)):
        diff.append(tab[i] - tab[i-1])
    return diff

print(delta([1000, 800, 802, 1000, 1003]))
print(delta([42]))

PDF

03_02.py : POO et arbres (Tle) : Arbre binaire et expression arithmétique

Sujet 2 :
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
    


Correction :
# 2022 Sujet 3 ex 2
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, g, v, d):
        self.gauche = g
        self.valeur = v
        self.droit = d

    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

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 expression_infixe(e):
    s = ''
    if e.gauche is not None:
        s = '(' + s + expression_infixe(e.gauche)
    s = s + str(e.valeur)
    if e.droit is not None:
        s = s + expression_infixe(e.droit) + ')'
    return s

print(expression_infixe(e))

PDF

04_01.py : Recherche des couples d'entiers consécutifs dans un tableau (1er)

# 2022 Sujet 4 ex 1
def recherche(tab):
    solution = []
    for i in range(len(tab)-1):
        if tab[i] + 1 == tab[i+1]:
            solution.append((tab[i], tab[i+1]))
    return solution

print(recherche([1, 4, 3, 5]))

print(recherche([1, 4, 5, 3]))
 
print(recherche([7, 1, 2, 5, 3, 4]))
 
print(recherche([5, 1, 2, 3, 8, -5, -4, 7]))

PDF

04_02.py : Recursif (Tle) : Codage d'une image en liste de listes

Sujet 2 :
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)

Correction :
# 2022 Sujet 4 ex 1
def propager(M, i, j, val):
    if M[i][j]== 0 :
        return None

    M[i][j] = val

    # l'élément en haut fait partie de la composante
    if ((i-1) >= 0 and M[i-1][j] == 1):
        propager(M, i-1, j, val)

    # l'élément en bas fait partie de la composante
    if ((i+1) < len(M) and M[i+1][j] == 1):
        propager(M, i+1, j, val)

    # l'élément à gauche fait partie de la composante
    if ((j-1) >= 0 and M[i][j-1] == 1):
        propager(M, i, j-1, val)

    # l'élément à droite fait partie de la composante
    if ((j+1) < len(M) and M[i][j+1] == 1):
        propager(M, i, j+1, val)

M = [[0,0,1,0],[0,1,0,1],[1,1,1,0],[0,1,1,0]]
print(M)
propager(M,2,1,3)
print(M)

PDF

05_01.py : Dictionnaires deux clés ‘min’ et ‘max’. (1er)

# 2022 Sujet 5 ex 1
def rechercheMinMax(tab):
    if tab == []:
        return {'min': None, 'max': None}
    d = {}
    d['min'] = tab[0]
    d['max'] = tab[0]
    for val in tab:
        if val < d['min']:
            d['min'] = val
        if val > d['max']:
            d['max'] = val
    return d

# tests
tableau = [0, 1, 4, 2, -2, 9, 3, 1, 7, 1]
print(rechercheMinMax(tableau))

tableau = []
print(rechercheMinMax(tableau))

PDF

05_02.py : POO (Tle) : cartes et paquet de cartes

Sujet 2 :
class Carte:
    """Initialise Couleur (entre 1 a 4), et Valeur (entre 1 a 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):
        ??? = [ ??? for couleur in range(1, ???) for valeur in range( 1, ???)]

    """Renvoie la Carte qui se trouve a  la position donnee"""
    def getCarteAt(self, pos):
        if 0 <= pos < ??? :
            return ???

Correction :
# 2022 Sujet 5 ex 2
class Carte:
    """Initialise Couleur (entre 1 à 4), et Valeur (entre 1 à 13)"""
    def __init__(self, c, v):
        assert c in range(1, 5)
        assert v in range(1, 14)
        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):
        self.contenu = [Carte(couleur, valeur) for couleur in range(1, 5) for valeur in range(1, 14)]

    """Renvoie la Carte qui se trouve à la position donnée"""
    def getCarteAt(self, pos):
        assert pos in range(0, 52)
        if 0 <= pos < len(self.contenu) :
            return self.contenu[pos]

# Tests
unPaquet = PaquetDeCarte()
unPaquet.remplir()
uneCarte = unPaquet.getCarteAt(20)
print(uneCarte.getNom() + " de " + uneCarte.getCouleur())

PDF

06_01.py : Valeur et indice du maximum dans une liste (1er)

# 2022 - sujet 6 - ex1
# Écrire une fonction maxi qui prend en paramètre une liste tab de nombres entiers
#et qui renvoie un couple donnant le plus grand élément de cette liste
# ainsi que l’indice de la première apparition de ce maximum dans la liste.
def maxi(tab):
    if tab==[]: return None,None
    indice_maxi,maxi = 0, tab[0]
    for indice in range(1,len(tab)):
        if tab[indice]>maxi:
            indice_maxi,maxi = indice,tab[indice]
    return (maxi,indice_maxi)

print(maxi([1,5,6,9,1,2,3,7,9,8]))

PDF

06_02.py : Recherche textuelle d'une suite de caractères dans un texte (1er)

Sujet 2 :
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

Correction :
# 2022 - sujet 6 - ex2

def recherche(gene, seq_adn):
    n = len(seq_adn) # la longueur de la chaine (n)
    g = len(gene) #   la longueur du motif (g)
    i = 0 # C'est l'indice i de parcours de la chaîne, initialisé à 0
    trouve = False
    while i < n-g+1 and trouve == False :
        # La recherche continue tant que i est inférieure strictement à n - g +1
        # ou inférieure ou égale à n-g
        # et que la motif n'a pas été trouvé
        j = 0
        while j < g and gene[j] == seq_adn[i+j]:
            j += 1 # On a une correspondance, j est l'indice de parcours du motif,
            # on continue à chercher en avançant dans le motif j--> j+1.
        if j == g:
            trouve = True
        i+=1 #


    return trouve

print(recherche("AATC", "GTACAAATCTTGCC"))
print(recherche("AGTC", "GTACAAATCTTGCC"))
# on teste quand la séquence est à la fin ou au début
print(recherche("AGTC", "GTACAAATCTTGCCAGTC"))
print(recherche("AGTC", "AGTCGTACAAATCTTGCC"))

PDF

07_01.py : Conversion binaire/décimal (1er)

# 2022 -sujet 7 - ex1
# Écrire une fonction conv_bin qui prend en paramètre un entier positif n
# et renvoie un couple (b,bit) où :
#b est une liste d'entiers correspondant à la représentation binaire de n;
#  bit correspond aux nombre de bits qui constituent b.
def conv_bin(n):
    liste_bit=[n%2] # initialisation permettant de traiter le cas où n=0
    n=n//2
    while n!=0:
        liste_bit.append(n%2)
        n=n//2
    liste_bit.reverse()
    return (liste_bit,len(liste_bit))

# tests : on peut utiliser la fonction bin pour les tests
n=9
print(n,conv_bin(n),bin(n))
n=0
print(n,conv_bin(n),bin(n))
n=16
print(n,conv_bin(n),bin(n))
n=164
print(n,conv_bin(n),bin(n))

PDF

07_02.py : Tris (Tle) : Tri à bulles

Sujet 2 :
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

Correction :
# 2022 -sujet 7 - ex2
# La fonction tri_bulles prend en paramètre une liste T d’entiers non triés
# et renvoie la liste triée par ordre croissant.
def tri_bulles(T):
    n = len(T)
    for i in range(n-1,0,-1):
        # On parcourt la liste à l'envers à l'aide de l'indice i
        # (le dernier élément de T a pour indice len(T)-1)
        for j in range(i):
            if T[j] > T[j+1]: # Dans ce cas on échange les éléments
                # en utilisant ici un variable tampon : temp
                temp = T[j]
                T[j] = T[j+1]
                T[j+1] = temp
    return T


# tests :
T=[5,10,0,-50,15,3,780]
print(tri_bulles(T))

T=[500,100,0,-50,15,3,-780]
print(tri_bulles(T))

PDF

08_01.py : Recherche indice de la première occurrence dans un tableau (1er)

# 2022 -sujet 8 - ex1
# Écrire une fonction recherche qui prend en paramètres elt un nombre entier et tab un tableau de nombres entiers,
# et qui renvoie l’indice de la première occurrence de elt dans tab si elt est dans tab et -1 sinon.
def recherche(elt, tab):
    for i in range(len(tab)):
        if tab[i] == elt:
            return i        
    return -1     

(elt, tab)=(2, [-10,2,-20,4,50,20,3,-3])
print(recherche(elt, tab))
(elt, tab)=(-3, [-10,2,-20,4,50,20,3,-3])
print(recherche(elt, tab))
(elt, tab)=(-10, [-10,2,-20,4,50,20,3,-3])
print(recherche(elt, tab))
(elt, tab)=(200, [-10,2,-20,4,50,20,3,-3])
print(recherche(elt, tab))

PDF

08_02.py : Insertion dans une liste triée (1er)

Sujet 2 :
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

Correction :
# 2022 -sujet 8 - ex2
# On considère la fonction insere ci-dessous qui prend en argument un entier a et un tableau tab d'entiers triés par ordre croissant.
# Cette fonction insère la valeur a dans le tableau et renvoie le nouveau tableau.
# Les tableaux seront représentés sous la forme de listes python.
#
def insere(a, tab):
    l = list(tab) #l contient les mêmes éléments que tab
    # La ligne 2 a pour but de faire une copie du tableau tab afin de ne pas le modifier.
    # On aurait pu utiliser copy.
    l.append(a)
    i = len(l) - 2
    while a < l[i] and i >= 0:
        #On échange a avec le précédent
        # tant qu'il est inférieur et que le début de liste n'est pas atteint.
        l[i+1] = l[i]
        l[i] = a
        i = i - 1
    return l


(a, tab)=(-2,[-3,10,20,30,40])
print(insere(a, tab))
(a, tab)=(40,[-3,10,20,30,40])
print(insere(a, tab))
(a, tab)=(50,[-3,10,20,30,40])
print(insere(a, tab))

PDF

09_01.py : Suite de Collatz (1er)

# 2022 -sujet 9 - ex1
# Écrire une fonction calcul prenant en paramètres un entier n strictement positif et qui renvoie la liste des valeurs un ,
#en partant de k et jusqu’à atteindre 1.
def calcul(k):
  resultat=[k]
  while k!=1:
    if k%2==0: 
      k=k//2
    else:
      k=3*k+1
    resultat.append(k)
  return resultat

print(calcul(7))

PDF

09_02.py : Dictionnaires : Codage d'un mot (1er)

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_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]

Correction :
# 2022 -sujet 9 - ex2
#
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 = 0
    for c in mot :
        code_c = code_c + str(dico[c])
        code_a = code_a + dico[c]
    code_c = int(code_c)
    if code_c % code_a == 0:
        mot_est_parfait = True
    else :
        mot_est_parfait = False
    return [code_a, code_c, mot_est_parfait]

mot='PAUL'
print(mot,est_parfait(mot) )
mot='ALAIN'
print(mot,est_parfait(mot) )

PDF

10_01.py : Dictionnaires : Nombre d'occurrence avec un dictionnaire (1er)

# 2022 -sujet 10 - ex1
# Écrire une fonction occurence_lettres avec prenant comme paramètre une variable phrase de type str.
#Cette fonction doit renvoyer un dictionnaire de type constitué des occurrences des caractères présents dans la phrase.
def occurrence_lettres(phrase):
    occ = {}
    for caractere in phrase:
        if caractere in occ:
            occ[caractere] += 1
        else:
            occ[caractere] = 1
    return occ

phrase='hello'
print(phrase,occurrence_lettres(phrase))

phrase='Hello world !'
print(phrase,occurrence_lettres(phrase))

PDF

10_02.py : Fusion de deux listes triées (1er)

Sujet 2 :
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

Correction :
# 2022 -sujet 10 - ex2
# La fonction fusion prend deux listes L1,L2 d’entiers triées par ordre croissant et les fusionne en une liste triée L12 qu’elle renvoie.
def fusion(L1,L2):
    n1 = len(L1)
    n2 = len(L2)
    L12 = [0]*(n1+n2)
    i1 = 0
    i2 = 0
    i = 0
    while i1 < n1 and i2 < n2 :
        # i1 est l'indice de parcours de L1 (de longueur n1) i2 est l'indice de parcours de L2 (de longueur n2)
        if L1[i1] < L2[i2]:
            #On se trouve dans le cas où le plus petit élément se trouve dans L1, c'est donc lui qui est ajouté à liste fusionnée L12.
            L12[i] = L1[i1]
            i1 = i1 + 1
        else:
            L12[i] = L2[i2]
            i2 = i2 + 1
        i += 1
    while i1 < n1:
        # On a atteint la fin de l'une des listes, il reste donc à ajouter les éléments restants de l'autre liste. 
        L12[i] = L1[i1]
        i1 = i1 + 1
        i = i + 1
    while i2 < n2:
        L12[i] = L2[i2]
        i2 = i2 + 1
        i = i + 1
    return L12

(L1,L2)=([-10,0,10,20,30,40],[-2,-1,0,5,10,20,25,27,50])
print(fusion(L1,L2))

print(fusion([1,6,10],[0,7,8,9]))

PDF

11_01.py : Dichotomie (1er)

# 2022 -sujet 11 - ex1
#Écrire une fonction recherche qui prend en paramètres un tableau tab de nombres entiers triés par ordre croissant
# et un nombre entier n, et qui effectue une recherche dichotomique du nombre entier n dans le tableau non vide tab.
# Cette fonction doit renvoyer un indice correspondant au nombre cherché s’il est dans le tableau, -1 sinon.
def recherche(tab, n):
    ind_debut = 0
    ind_fin = len(tab) - 1
    while ind_debut <= ind_fin:
        ind_milieu = (ind_debut + ind_fin) // 2
        if tab[ind_milieu] == n:
            return ind_milieu
        elif tab[ind_milieu] < n:
            ind_debut = ind_milieu + 1
        else:
            ind_fin = ind_milieu - 1
    return -1

(tab, n)=([-10,-5,0,2,3,5,20],5)
print((tab, n),recherche(tab, n))

(tab, n)=([2, 3, 4, 5, 6],3)
print((tab, n),recherche(tab, n))

(tab, n)=([2, 3, 4, 6, 7],5)
print((tab, n),recherche(tab, n))

(tab, n)=([2, 3, 4, 6, 7],2)
print((tab, n),recherche(tab, n))

(tab, n)=([2, 3, 4, 6, 7],7)
print((tab, n),recherche(tab, n))

PDF

11_02.py : Code de César (1er) - Rem : utilisation de la méthode find()

Sujet 2 :
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

Correction :
# 2022 -sujet 11 - ex2
ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'

def position_alphabet(lettre):
    return ALPHABET.find(lettre)

def cesar(message, decalage):
    resultat = ''
    for lettre in message:
        if lettre in ALPHABET:
            indice = (position_alphabet(lettre) + decalage) % 26
            resultat = resultat + ALPHABET[indice]
        else:
            resultat = resultat + lettre
    return resultat

print(cesar('BONJOUR A TOUS. VIVE LA MATIERE NSI !',4))

print(cesar('GTSOTZW F YTZX. ANAJ QF RFYNJWJ SXN !',-5))

PDF

12_01.py : Calcul d'une moyenne (1er)

# 2022 -sujet 12 - ex1
#Programmer la fonction moyenne prenant en paramètre un tableau d'entiers tab (type list)
#qui renvoie la moyenne de ses éléments si le tableau est non vide et affiche 'erreur' si le tableau est vide.
def moyenne(tab):
    if tab == []:
        print('erreur')
        return None
    else:
        somme = 0
        for elt in tab:
            somme += elt
        return somme / len(tab)

# on utilise la fonction um(tab)/len(tab) pour les tests
tab=[-10,10]
print(moyenne(tab),sum(tab)/len(tab))

tab=[]
print(moyenne(tab))

tab=[-100,50,20,30,60,148,1]
print(moyenne(tab),sum(tab)/len(tab))

PDF

12_02.py : Séparation des 0 et des 1 dans une liste (1er)

Sujet 2 :
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= ...
    ...

Correction :
# 2022 -sujet 12 - ex2
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 = 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

print(tri([0,1,0,1,0,1,0,1,0]))

tri([0,1,0,1,0,1,0,1,1])

PDF

13_01.py : Glouton : Rendu de monnaie (1er)

# 2022 -sujet 13 - ex1
def rendu(somme_a_rendre):
    pieces = [5, 2, 1]
    retour = [0, 0, 0]
    reste_a_rendre = somme_a_rendre
    for i in range(3):
        retour[i] = reste_a_rendre // pieces[i]
        reste_a_rendre = reste_a_rendre % pieces[i]
    return retour

somme_a_rendre=13
print(somme_a_rendre,rendu(somme_a_rendre))
somme_a_rendre=64
print(somme_a_rendre,rendu(somme_a_rendre))
somme_a_rendre=89
print(somme_a_rendre,rendu(somme_a_rendre))
somme_a_rendre=0
print(somme_a_rendre,rendu(somme_a_rendre))

PDF

13_02.py : POO et liste chainée (Tle) : gestion d'une file

Sujet 2 :
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 

Correction :
# 2022 -sujet 13 - ex2
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(element)
        nouveau_maillon.suivant =  self.dernier_file
        self.dernier_file = nouveau_maillon

    def est_vide(self) :
        return self.dernier_file == None

    def affiche(self) :
        maillon = self.dernier_file
        while maillon != None :
            print(maillon.valeur)
            maillon = maillon.suivant

    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 = self.dernier_file
            while maillon.suivant.suivant != None :
                maillon = maillon.suivant
            resultat = maillon.suivant.valeur
            maillon.suivant = None
            return resultat
        return None


F = File()
print(F.est_vide())
#True
print(F.enfile(2))
print(F.affiche())
#2
print(F.est_vide())
#False
print(F.enfile(5))
print(F.enfile(7))
print(F.affiche())
print(F.defile())
print(F.defile())
print(F.affiche())

PDF

14_01.py : Mots correspondants à un motif dans une chaine de caractères (1er)

# 2022 -sujet 14 - ex1
def correspond(mot, mot_a_trous):
    if len(mot) != len(mot_a_trous):
        return False
    for i in range(len(mot)):
        if mot[i] != mot_a_trous[i] and mot_a_trous[i] != '*':
            return False
    return True


print(correspond('INFORMATIQUE', 'INFO*MA*IQUE'))

print(correspond('AUTOMATIQUE', 'INFO*MA*IQUE'))

PDF

14_02.py : Dictionnaires : Recherche d'un cycle dans un dictionnaire (1er)

Sujet 2 :
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 ...

Correction :
# 2022 -sujet 14 - ex2
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(plan)
    for i in range(N-1):
        if plan[personne] == 'A':
            return False
        else:
            personne = plan[personne]
    return True

print(est_cyclique({'A':'E', 'F':'A', 'C':'D', 'E':'B', 'B':'F', 'D':'C'}))

print(est_cyclique({'A':'E', 'F':'C', 'C':'D', 'E':'B', 'B':'F', 'D':'A'}))

print(est_cyclique({'A':'B', 'F':'C', 'C':'D', 'E':'A', 'B':'F', 'D':'E'}))

print(est_cyclique({'A':'B', 'F':'A', 'C':'D', 'E':'C', 'B':'F', 'D':'E'}))

PDF

15_01.py : Nombre de répétitions d'un élément (1er)

# 2022 -sujet 15 - ex1
def nb_repetitions(elt, tab):
    nb = 0
    for element in tab:
        if element == elt:
            nb += 1
    return nb

print(nb_repetitions(5,[2,5,3,5,6,9,5]))

print(nb_repetitions('A',[ 'B', 'A', 'B', 'A', 'R']))

print(nb_repetitions(12,[1, '! ',7,21,36,44]))

PDF

15_02.py : Conversion en binaire (1er)

Sujet 2 :
def binaire(a):
    bin_a = str(...)
    a = a // 2
    while a ... :
        bin_a = ...(a%2) + ...
        a = ...
    return bin_a

Correction :
# 2022 -sujet 15 - ex2
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

# pour les tests on peut utiliseeer la fonctions bin
a=0
print(a,binaire(a),bin(a))

a=77
print(a,binaire(a),bin(a))

a=10
print(a,binaire(a),bin(a))

PDF

16_01.py : Maximum d'un élément dans une liste (1er)

# 2022 - sujet 16 - ex1
def maxi(tab):
    val_max = tab[0]
    pos_max = 0
    for i in range(len(tab)):
        if tab[i] > val_max:
            val_max = tab[i]
            pos_max = i
    return (val_max, pos_max)


print(maxi([1,5,6,9,1,2,3,7,9,8]))

PDF

16_02.py : Piles (Tle) : Structure de données : piles

Sujet 2 :
def positif(T):
    T2 = ...(T)
    T3 = ...
    while T2 != []:
        x = ...
        if ... >= 0:
            T3.append(...)
    T2 = []
    while T3 != ...:
        x = T3.pop()
        ...
    print('T = ',T)
    return T2


Correction :
# 2022 - sujet 16 - ex2
def positif(T):
    T2 = list(T) # on peut aussi utiliser la fonction copy afin de ne pas modifier T
    T3 = []
    while T2 != []:
        x = T2.pop()
        if x >= 0:
            T3.append(x)
    T2 = [] # <- NB : cette ligne est inutile
    while T3 != []:
        x = T3.pop()
        T2.append(x)
    print('T = ',T)
    return T2


print(positif([-1,0,5,-3,4,-6,10,9,-8 ]))

PDF

17_01.py : Nombre de mots dans une phrase (1er)

# 2022 - sujet 17 - ex1def nombre_de_mots(phrase):
def nombre_de_mots(phrase):
    nb_mots = 0
    for caractere in phrase:
        if caractere == ' ' or caractere == '.':
            nb_mots += 1
    return nb_mots

print(nombre_de_mots('Le point d exclamation est separe !'))
print(nombre_de_mots('Il y a un seul espace entre les mots !'))

PDF

17_02.py : POO (Tle) : arbre binaire de recherche

Sujet 2 :
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 ...

Correction :
# 2022 - sujet 17 - ex2
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(self.racine.valeur)
            self.racine.droite.parcours(tab)
            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 False
        else:
            if element < self.racine.valeur:
                return self.racine.gauche.recherche(element)
            elif element > self.racine.valeur:
                return self.racine.droite.recherche(element)
            else:
                return True
            
a = ABR()
a.insere(7)
a.insere(3)
a.insere(9)
a.insere(1)
a.insere(9)
print(a.parcours())
#[1, 3, 7, 9, 9]
print(a.recherche(4))
#False
print(a.recherche(3))
#True

PDF

18_01.py : Minimum d'une liste de températures (1er)

# 2022 - sujet 18 - ex1
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):
    temp_mini = releve[0]
    date_mini = date[0]
    for i in range(len(releve)):
        if releve[i] < temp_mini:
            temp_mini = releve[i]
            date_mini = date[i]
    return (temp_mini, date_mini)

print(mini(t_moy, annees))

PDF

18_02.py : Palindrome (1er)

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 :
# 2022 - sujet 18 - ex2
def inverse_chaine(chaine):
    result = ''
    for caractere in chaine:
        result = caractere + result
    return result

def est_palindrome(chaine):
    inverse = inverse_chaine(chaine)
    return chaine == inverse

def est_nbre_palindrome(nbre):
    chaine = str(nbre)
    return est_palindrome(chaine)

print(inverse_chaine('bac'))
print(est_palindrome('NSI'))
print(est_palindrome('ISN-NSI'))
print(est_nbre_palindrome(214312))
print(est_nbre_palindrome(213312))

PDF

19_01.py : Multiplications avec uniquement additions et soustractions (1er)

# 2022 - sujet 19 - ex1
def multiplication(n1, n2):
    if n1 < 0:
        return -multiplication(-n1, n2)
    if n2 < 0:
        return -multiplication(n1, -n2)
    resultat = 0
    for _ in range(n2):
        resultat += n1
    return resultat

n1,n2=3,5
print(n1,n2,multiplication(n1, n2))

n1,n2=-4,-8
print(n1,n2,multiplication(n1, n2))

n1,n2=-2,6
print(n1,n2,multiplication(n1, n2))

n1,n2=-2,0
print(n1,n2,multiplication(n1, n2))

PDF

19_02.py : Dichotomie : Recherche dichotomique (1er)

Sujet 2 :
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 ??? 

Correction :
# 2022 - sujet 19 - ex2
def chercher(T, n, i, j):
    if i < 0 or j >= len(T) :
        print('Erreur')
        return None
    if i > j :
        return None
    m = (i + j) // 2
    if T[m] < n :
        return chercher(T, n, m + 1, j)
    elif T[m] > n :
        return chercher(T, n, i, m - 1 )
    else :
        return m

(T, n, i, j)=([1,5,6,6,9,12],7,0,10)
print((T, n, i, j),chercher(T, n, i, j))

(T, n, i, j)=([1,5,6,6,9,12],7,0,5)
print((T, n, i, j),chercher(T, n, i, j))

(T, n, i, j)=([1,5,6,6,9,12],9,0,5)
print((T, n, i, j),chercher(T, n, i, j))

(T, n, i, j)=([1,5,6,6,9,12],6,0,5)
print((T, n, i, j),chercher(T, n, i, j))

PDF

20_02.py : POO (Tle) : Test de carrés magiques

Sujet 2 :
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 ...   



Correction :
# 2022 - sujet 20 - ex2
#Compléter la fonction est_magique qui prend en paramètre un carré et qui renvoie
# la valeur de la somme si ce carré est magique, False sinon.
class Carre:
    def __init__(self, tableau = [[]]):
        # Attention ici la variable est modifiée par la fonction
        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(1,n):
        #Par la peine de tester la ligne d'indice 0,
        # elle a servi à calculer la somme de référence s   .
        if carre.somme_ligne(i) != s:
            return False
    #test de la somme de chaque colonne
    for j in range(n):
        if carre.somme_col(j) != s: #
            return False
    #test de la somme de chaque diagonale
    if sum([carre.valeurs[k][k] for k in range(n)]) != s: #
        # La diagonale principale se caractérise par des indices
        # de lignes et de colonne identiques.
            return False
    if sum([carre.valeurs[k][n-1-k] for k in range(n)]) != s:
            return False
    return s   #

c=Carre([[1, 1],
        [1, 1]])
Carre.affiche(c)
print(est_magique(c))

c=Carre([[2, 9, 4],
         [7, 5, 3],
        [6, 1, 8]])
Carre.affiche(c)
print(est_magique(c))

c=Carre([[4, 5, 16, 9],
         [14, 7, 2, 11],
         [3, 10, 15, 6],
         [13, 12, 8, 1]])
Carre.affiche(c)
print(est_magique(c))

PDF

21_01.py : Multiplications avec uniquement additions et soustractions (1er)

# 2022 - sujet 21 - ex1
# Programmer la fonction multiplication, prenant en paramètres deux nombres
#entiers n1 et n2, et qui renvoie le produit de ces deux nombres.
#Les seules opérations autorisées sont l’addition et la soustraction.
def multiplication(n1, n2):
    if n1 < 0:
        return -multiplication(-n1, n2)
    if n2 < 0:
        return -multiplication(n1, -n2)
    resultat = 0
    for _ in range(n2):
        resultat += n1
    return resultat

n1,n2=3,5
print(n1,n2,multiplication(n1, n2))

n1,n2=-3,5
print(n1,n2,multiplication(n1, n2))

n1,n2=-3,-5
print(n1,n2,multiplication(n1, n2))

PDF

21_02.py : Dichotomie : Recherche dichotomique dans un tableau trié (1er)

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 :
# 2022 - sujet 21 - ex2def dichotomie(tab, x):

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 = (debut + fin) // 2
        if x == tab[m]:
            return True
        if x > tab[m]:
            debut = m + 1
        else:
            fin = m - 1
    return False


print(dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],28))
print(dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],27))

PDF

22_01.py : Ecriture d'une chaîne de caractères à l'envers (1er)

#2022 - sujet 22 - ex1
def renverse(mot):
    sol = ''
    for lettre in mot:
        sol = lettre + sol
    return sol

print(renverse("informatique"))

PDF

22_02.py : Crible d'Eratosthène (1er)

Sujet 2 :
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]

Correction :
#2022 - sujet 22 - ex2
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(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]

PDF

23_01.py : Dictionnaires : Maximum des valeurs d'un dictionnaire (1er)

#2022 - sujet 23 - ex1
def max_dico(dico):
    cle_max = ''
    val_max = 0
    for cle in dico:
        if dico[cle] > val_max:
            val_max = dico[cle]
            cle_max = cle
    return (cle_max, val_max)

print(max_dico({'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50}))
print(max_dico({'Alan': 222, 'Ada': 201, 'Eve': 220, 'Tim': 50}))

PDF

23_02.py : POO (Tle) : pile pour noter une expression arithmétique

Sujet 2 :
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 ...

Correction :
#2022 - sujet 23 - ex2
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 element in tab:
        print(element)
        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()

print(eval_expression([2, 3, '+', 5, '*']))

PDF

24_01.py : Maximum des éléments d'une liste et son indice (1er)

#2022 - sujet 24 - ex1
def maxliste(tab):
    maximum = tab[0]
    for element in tab:
        if element > maximum:
            maximum = element
    return maximum

print(maxliste([98, 12, 104, 23, 131, 9]))
print(maxliste([-27, 24, -3, 15]))
print(maxliste([-27, 24, -3, 150]))
print(maxliste([500, 24, -3, 15]))

PDF

24_02.py : POO (Tle) : expression bien parenthésée et piles

Sujet 2 :
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

Correction :
#2022 - sujet 24 - ex2
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 False
            else:
                p.depiler()
    return p.est_vide()


print(parenthesage("((()())(()))"))
assert parenthesage("((()())(()))") == True
assert parenthesage("())(()") == False
assert parenthesage("(())(()") == False

PDF

25_01.py : Traitement de données en tables. (1er)

#2022 - sujet 25 - ex1
def selection_enclos(table_animaux, num_enclos):
    table = []
    for animal in table_animaux:
        if animal['enclos'] == num_enclos:
            table.append(animal)
    return table

animaux = [ {'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2},
{'nom':'Titine', 'espece':'chat', 'age':2, 'enclos':5},
{'nom':'Tom', 'espece':'chat', 'age':7, 'enclos':4},
{'nom':'Belle', 'espece':'chien', 'age':6, 'enclos':3},
{'nom':'Mirza', 'espece':'chat', 'age':6, 'enclos':5}]

print(selection_enclos(animaux, 5))
print(selection_enclos(animaux, 2))
print(selection_enclos(animaux, 7))

PDF

25_02.py : Recursif (Tle) : Recherche récursive dans un tableau

Sujet 2 :
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 ...

Correction :
#2022 - sujet 25 - ex2
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 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, g, indice)
        else:
            return trouver_intrus(tab, indice + 3, d)

tab_a = [3, 3, 3, 9, 9, 9, 1, 1, 1, 7, 2, 2, 2, 4, 4, 4, 8, 8, 8, 5, 5, 5]
#l'intrus est 7
tab_b = [8, 5, 5, 5, 9, 9, 9, 18, 18, 18, 3, 3, 3] #l'intrus est 8
tab_c = [5, 5, 5, 1, 1, 1, 0, 0, 0, 6, 6, 6, 3, 8, 8, 8] #l'intrus est 3

print(trouver_intrus(tab_a, 0, 21))
print(trouver_intrus(tab_b, 0, 12))
print(trouver_intrus(tab_c, 0, 15))

PDF

26_01.py : Minimum : l'indice de la première occurrence du minimum d'un tableau (1er)

#2022 - sujet 26 - ex1
def RechercheMin(tab):
    indice_min = 0
    for i in range(len(tab)):
        if tab[i] < tab[indice_min]:
            indice_min = i
    return indice_min

print(RechercheMin([5]))
print(RechercheMin([2, 4, 1]))
print(RechercheMin([5, 3, 2, 2, 4]))

PDF

26_02.py : Séparation des 0 et des 1 dans une liste (1er)

Sujet 2 :
def separe(tab):
    i = 0
    j = ...
    while i < j :
        if tab[i] == 0 :
            i = ...
        else :
            tab[i], tab[j] = ...
            j = ...
    return tab

Correction :
#2022 - sujet 26 - ex2
def separe(tab):
    i = 0
    j = len(tab) - 1
    while i < j :
        if tab[i] == 0 :
            i = i + 1
        else :
            tab[i], tab[j] = tab[j], tab[i]
            j = j - 1
    return tab

print(separe([1, 0, 1, 0, 1, 0, 1, 0]))
print(separe([1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0]))

PDF

27_01.py : Arbre recursif dictionnaire (Tle)

#2022 - sujet 27 - ex1
a = {'F':['B','G'], 'B':['A','D'], 'A':['',''], 'D':['C','E'], 'C':['',''], 'E':['',''], 'G':['','I'], 'I':['','H'], 'H':['','']}

def taille(arbre, lettre):
    fils_gauche = arbre[lettre][0]
    fils_droit = arbre[lettre][1]

    if fils_gauche != '' and fils_droit != '':
        return 1 + taille(arbre, fils_gauche) + taille(arbre, fils_droit)

    if fils_gauche != '' and fils_droit == '':
        return 1 + taille(arbre, fils_gauche)

    if fils_gauche == '' and fils_droit != '':
        return 1 + taille(arbre, fils_droit)

    else:
        return 1
 
print(taille(a, 'F'))

PDF

27_02.py : Tri par sélection (1er)

Sujet 2 :
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

Correction :
#2022 - sujet 27 - ex2
def tri_iteratif(tab):
    for k in range(len(tab)-1, 0, -1):
        imax = 0
        for i in range(0, k):
            if tab[i] > tab[imax] :
                imax = i
        if tab[imax] > tab[k] :
            tab[k], tab[imax] = tab[imax], tab[k] 
    return tab

print(tri_iteratif([41, 55, 21, 18, 12, 6, 25]))

PDF

28_01.py : Calcul de moyenne (1er)

#2022 - sujet 28 - ex1
def moyenne(tab):
    somme = 0
    for val in tab:
        somme += val
    return somme / len(tab)

print(moyenne([1.0]))
print(moyenne([1.0, 2.0, 4.0]))

PDF

28_02.py : Conversion décimal en binaire (1er)

Sujet 2 :
def dec_to_bin(a):
    bin_a = ...
    a = a//2
    while a ... :
        bin_a = ... + bin_a
        a = ...
    return bin_a

Correction :
#2022 - sujet 28 - ex2
def dec_to_bin(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

#on peut utiliser la fonction bin pour les tests

a=0
print(a,dec_to_bin(a),bin(a))

a=83
print(a,dec_to_bin(a),bin(a))

a=127
print(a,dec_to_bin(a),bin(a))

PDF

29_01.py : Termes de la suite de Fibonacci (1er)

#2022 - sujet 29 - ex1def fibonnaci(n):
def fibonnaci(n):
    d = {}
    d[1] = 1
    d[2] = 1
    for k in range(3, n+1):
        d[k] = d[k-1] + d[k-2]
    return d[n]


n=1
print(n,fibonnaci(n))

n=2
print(n,fibonnaci(n))

n=25
print(n,fibonnaci(n))

n=45
print(n,fibonnaci(n))

PDF

29_02.py : Recherche de maximum dans une liste (1er)

Sujet 2 :
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)

Correction :
#2022 - sujet 29 - ex2

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 = 0
    liste_maxi = []

    for compteur in range(len(liste_eleves)):
        if liste_notes[compteur] == note_maxi:
            nb_eleves_note_maxi = nb_eleves_note_maxi + 1
            liste_maxi.append(liste_eleves[compteur])
        if liste_notes[compteur] > note_maxi:
            note_maxi = liste_notes[compteur]
            nb_eleves_note_maxi = 1
            liste_maxi = [liste_eleves[compteur]]

    return (note_maxi,nb_eleves_note_maxi,liste_maxi)

print(meilleures_notes())

PDF

30_01.py : Tri et fusion : Fusion de deux listes déjà triées (1er)

#2022 - sujet 30 - ex1

def fusion(tab1, tab2):
    tab_fusion = []
    i1 = 0
    i2 = 0
    while i1 < len(tab1) and i2 < len(tab2):
        if tab1[i1] < tab2[i2]:
            tab_fusion.append(tab1[i1])
            i1 += 1
        else:
            tab_fusion.append(tab2[i2])
            i2 += 1

    if i1 == len(tab1):
        while i2 < len(tab2):
            tab_fusion.append(tab2[i2])
            i2 += 1
    else:
        while i1 < len(tab1):
            tab_fusion.append(tab1[i1])
            i1 += 1        

    return tab_fusion

print(fusion([3, 5], [2, 5]))
print(fusion([-2, 4], [-3, 5, 10]))
print(fusion([4], [2, 6]))

PDF

30_02.py : Recursif et dictionnaires (Tle) : Conversion numération romaine

Sujet 2 :
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

Correction :
#2022 - sujet 30 - ex2

def rom_to_dec(nombre):

    """ Renvoie l’écriture décimale du nombre donné en chiffres romains """

    dico = {"I":1, "V":5, "X":10, "L":50, "C":100, "D":500, "M":1000}
    if len(nombre) == 1:
        return dico[nombre]

    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]] + rom_to_dec(nombre_droite)
        else:
            return rom_to_dec(nombre_droite) - dico[nombre[0]]

assert rom_to_dec("CXLII") == 142

PDF

31_01.py : Nombre d'occurrence d'un élément dans une liste (1er)

# 2022 sujet 31 - ex1
def recherche(a, t):
    nb = 0
    for element in t:
        if element == a:
            nb += 1
    return nb

print(recherche(5,[]))
print(recherche(5,[-2, 3, 4, 8]))
print(recherche(5,[-2, 3, 1, 5, 3, 7, 4]))
print(recherche(5,[-2, 5, 3, 5, 4, 5]))

PDF

31_02.py : Glouton : Rendu de monnaie (1er)

Sujet 2 :
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

Correction :
# 2022 sujet 31 - ex2
def rendu_monnaie_centimes(s_due, s_versee):
    pieces = [1, 2, 5, 10, 20, 50, 100, 200]
    rendu = []
    a_rendre = s_versee - s_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

print(rendu_monnaie_centimes(700,700))
print(rendu_monnaie_centimes(112,500))

PDF

32_01.py : Dernière occurrence d'un élément dans une liste (1er)

# 2022 sujet 32 - ex1

# Écrire une fonction recherche qui prend en paramètres elt un nombre
#et tab un tableau de nombres, et qui renvoie l’indice de la dernière
# occurrence de elt dans tab si elt est dans tab et le -1 sinon.

def recherche(elt, tab):
    n=len(tab)
    for i in range(n):
        if tab[n-i-1] == elt:
  # on parcourt la liste à l'envers pour avoir la première occurrence
            return n-i-1
    return -1

# autre solution
def recherche2(elt,tab):
    for i in range(len(tab)-1,-1,-1):
        if elt==tab[i]:
            return i
    return -1



(elt, tab)=(1,[2,3,4])
print((elt, tab),recherche(elt, tab),recherche2(elt, tab))

(elt, tab)=(1,[10,12,1,56])
print((elt, tab),recherche(elt, tab),recherche2(elt, tab))

(elt, tab)=(1,[1,50,1])
print((elt, tab),recherche(elt, tab),recherche2(elt, tab))

(elt, tab)=(1,[8,1,10,1,7,1,8])
print((elt, tab),recherche(elt, tab),recherche2(elt, tab))

PDF

32_02.py : POO (Tle) : adresse IP

Sujet 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
           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

Correction :
# 2022 sujet 32 - ex2

class AdresseIP:
    def __init__(self, adresse):
        self.adresse = 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 self.liste_octet()[3]==0 or self.liste_octet()[3]==0 #

    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 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')

print(adresse1.est_reservee())
print(adresse3.est_reservee())
print(adresse2.adresse_suivante().adresse)

PDF

33_01.py : Conversion binaire décimal (1er)

# 2022 sujet 33 - ex1

def convertir(T):
    poids =  len(T)-1
    valeur = 0
    for elt in T:
        valeur += 2**poids * elt
        poids -=1
    return valeur

T=[1, 0, 1, 0, 0, 1, 1]
print(T,convertir(T))

T=[1, 0, 0, 0, 0, 0, 1, 0]
print(T,convertir(T))

PDF

33_02.py : Tri par insertion (1er)

Sujet 2 :
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

Correction :
# 2022 sujet 33 - ex2
def tri_insertion(L):
    n = len(L)
    # cas du tableau vide
    if L==[]:
        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] > L[j]: #
            i = i - 1
        # 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,-1): #
                L[k] = L[k-1]
            L[i] = e #
    return L

# Attention pour les tests, la fonction modifie directement le tableau,
# essayer d'afficher print(tab,tri_insertion(tab))
tab=[2,5,-1,7,0,28]
print(tab)
tri_insertion(tab)
print(tab)

tab=[10,9,8,7,6,5,4,3,2,1,0]
print(tab)
tri_insertion(tab)
print(tab)

PDF

34_01.py : Lettre la plus fréquente dans un texte (1er)

# 2022 sujet 34 - ex2
alphabet = ['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
            'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
            's', 't', 'u', 'v', 'w', 'x', 'y', 'z']
# Il y a une faute de frappe dans la variable alphabet de l'énoncé
# (une virgule en trop dans la valeur 'o,')

def occurrence_max(ch):
    occurrence = [0]*26
    for caractere in ch:
        if caractere in alphabet:
            index_caractere = alphabet.index(caractere)
            occurrence[index_caractere] += 1
    indice_max_occurence = 0
    max_occurence = occurrence[0]
    for i in range(0,len(occurrence)):
        if occurrence[i]>max_occurence:
            max_occurence = occurrence[i]
            indice_max_occurence = i 
    return alphabet[indice_max_occurence]

ch='je suis en terminale et je passe le bac et je souhaite poursuivre des etudes pour devenir expert en informatique'
print(occurrence_max(ch))

PDF

34_02.py : Représentation d'une image par une liste de listes (1er)

Sujet 2 :
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(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'''

    # 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(len(image)):
        for j in range(...):
            if image[i][j] < ... :
                L[i][j] = ...
            else:
                L[i][j] = ...
    return L

Correction :
# 2022 sujet 34 - ex2
def nbLig(image):
    '''renvoie le nombre de lignes de l'image'''
    return len(image) #

def nbCol(image):
    '''renvoie la largeur de l'image'''
    return len(image[0]) #

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(nbCol(image)): #
            L[i][j] = 255-image[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(nbCol(image)): 
            if image[i][j] < seuil :
                # On applique l'algorithme donné en commentaire :
                #le pixel est mis à 0 s'il est inférieur au seuil et à 1 sinon.
                L[i][j] = 0
            else:
                L[i][j] = 1
    return L

img=[[20, 34, 254, 145, 6], [23, 124, 237, 225, 69], [197, 174, 207, 25, 87], [255, 0, 24, 197, 189]]
print(nbLig(img))
print(nbCol(img))
print(negatif(img))
print(binaire(img,120))

PDF

35_01.py : Calcul d'une moyenne (1er)

# 2022 sujet 35 - ex1
def moyenne(tab):
    '''
    moyenne(list) -> float
    Entrée : un tableau non vide d'entiers
    Sortie : nombre de type float
    Correspondant à la moyenne des valeurs présentes dans le
    tableau
    '''
    somme = 0
    for elt in tab:
        somme += elt
    return somme / len(tab)

assert moyenne([1]) == 1
assert moyenne([1,2,3,4,5,6,7]) == 4
assert moyenne([1,2]) == 1.5

PDF

35_02.py : Dichotomie : Recherche dichotomique (1er)

Sujet 2 :
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 ...

Correction :
# 2022 sujet 35 - ex2
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 tab == []:
        return False, 1
    # cas où x n'est pas compris entre les valeurs extrêmes
    if (x < tab[0]) or (x > 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

tab,x=[15, 16, 18, 19, 23, 24, 28, 29, 31, 33],28
print(tab,x,dichotomie(tab, x))

tab,x=[15, 16, 18, 19, 23, 24, 28, 29, 31, 33],27
print(tab,x,dichotomie(tab, x))

tab,x=[15, 16, 18, 19, 23, 24, 28, 29, 31, 33],1
print(tab,x,dichotomie(tab, x))

tab,x=[],28
print(tab,x,dichotomie(tab, x))

PDF

36_01.py : Dernière occurrence d'un élément dans une liste (1er)

# 2022 sujet 36 - ex1
def recherche(tab, n):
    indice_solution = len(tab)
    for i in range(len(tab)):
        if tab[i] == n:
            indice_solution = i
    return indice_solution


tab, n=  [5, 3],1 
print(tab,n,recherche(tab, n))

tab, n=  [2, 4],2 
print(tab,n,recherche(tab, n))

tab, n=  [2,3,5,2,4],2 
print(tab,n,recherche(tab, n))

PDF

36_02.py : Calcul de la distance entre deux points (1er)

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)

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"

Correction :
# 2022 sujet 36 - ex2

from math import sqrt

def distance(point1, point2):
    """ Calcule et renvoie la distance entre deux points. """
    assert int(point1[0]) == point1[0], "coordonnée non entière"
    assert int(point1[1]) == point1[1], "coordonnée non entière"
    assert int(point2[0]) == point2[0], "coordonnée non entière"
    assert int(point2[1]) == point2[1], "coordonnée non entière"
    return sqrt((point1[0] - point2[0])**2 + ((point1[1] - point2[1]))**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 = 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

assert plus_courte_distance([(7, 9), (2, 5), (5, 2)], (0, 0)) == (2, 5), "erreur"

PDF

37_01.py : Tri : Vérification si une liste est triée ou non (1er)

# 2022 sujet 37 - ex1
def verifie(tab):
    for i in range(1, len(tab)):
        if tab[i] < tab[i-1]:
            return False
    return True

tab=[0, 5, 8, 8, 9]
print(tab,verifie(tab))

tab=[8,12,4]
print(tab,verifie(tab))

tab=[-1,4]
print(tab,verifie(tab))

tab=[5]
print(tab,verifie(tab))

PDF

37_02.py : Dictionnaires : Comptabilisation de votes (1er)

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 :
# 2022 sujet 37 - ex2
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 = '' # même nom que la fonction ! et cette variable est inutile
    nmax = 0
    for candidat in election:
        if election[candidat] > nmax :
            nmax = election[candidat]
            vainqueur = candidat #
    liste_finale = [nom for nom in election if election[nom] == nmax]
    return liste_finale

# ATTENTION il y a une faute dans l'exemple proposé sur le sujet
election = depouille(urne)
print(urne,election)
print(vainqueur(election))

PDF

38_01.py : Tri : Tri par sélection (1er)

# 2022 sujet 38 - ex1

def tri_selection(tab):
    for i in range(len(tab)-1):
        indice_min = i
        for j in range(i+1, len(tab)):
            if tab[j] < tab[indice_min]:
                indice_min = j
        tab[i], tab[indice_min] = tab[indice_min], tab[i]
    return tab

print(tri_selection([1,52,6,-9,12]))

PDF

38_02.py : Jeu du nombre mystère (1er)

Sujet 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 :
# 2022 sujet 38 - ex2

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 était ', nb_mystere)
        print('Nombre d essais: ', compteur)
    else:
        print ('Perdu ! Le nombre était ', nb_mystere)

plus_ou_moins()

PDF

39_01.py : Calcul d'une moyenne (1er)

# 2022 sujet 39 - ex1

def moyenne(tab):
    somme = 0
    for val in tab:
        somme += val
    return somme / len(tab)

print(moyenne([10,20,30,40,60,110]))

PDF

39_02.py : Représentation d'une image par une liste de listes (1er)

Sujet 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):
    ''' 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

Correction :
# 2022 sujet 39 - ex2

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

affiche(coeur)
affiche(zoomDessin(coeur,3))

PDF

40_01.py : Recherche d'un élément dans une liste (1er)

# 2022 sujet 40 - ex1

def recherche(elt, tab):
    tab_indices = []
    for i in range(len(tab)):
        if tab[i] == elt:
            tab_indices.append(i)
    return tab_indices        

print(recherche(3, [3, 2, 1, 3, 2, 1]))

print(recherche(4, [1, 2, 3]))

PDF

40_02.py : Calcul de moyennes (dictionnaires) (1er)

Sujet 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):
    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

Correction :
# 2022 sujet 40 - ex2

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 resultats:
        notes = resultats[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
# pour les tests il faut calculer les moyennes pondérées  
print(moyenne('Durand'),(6*4+14.5*1+8*4+9*3+7*2+8*4+15*4)/(4+1+4+3+2+4+4))
print(moyenne('Dupont'))