code.txt

moyenne
;;;
Écrire une fonction moyenne qui prend en paramètre un tableau non vide d'entiers tab et qui renvoie la moyenne de ces entiers.
Il est interdit d'utiliser la fonction Python sum
Exemple :
>>> moyenne([10, 15, 20])
15.0
>>> moyenne([8, 11, 17, 10])
11.5
;;;
c = 0
if moyenne([10, 15, 20]) == 15:
    print("Test n°1 : OK")
    c += 1
else :
    print("Test n°1 : échec")
if moyenne([8, 11, 17, 10]) == 11.5:
    print("Test n°2 : OK")
    c += 1
else :
    print("Test n°2 : échec")
if c == 2 :
    print('OK')
else :
    print('KO')
;;;
maximum_tableau
;;;
Écrire la fonction maximum_tableau, prenant en paramètre un tableau non vide de nombres tab (de type list) et renvoyant le plus grand élément de ce tableau.
Il est interdit d'utiliser la fonction Python max
Exemples :
>>> maximum_tableau([98, 12, 104, 23, 131, 9])
131
>>> maximum_tableau([-27, 24, -3, 15])
24
;;;
c = 0
if maximum_tableau([98, 12, 104, 23, 131, 9]) == 131:
    print("Test n°1 : OK")
    c += 1
else :
    print("Test n°1 : échec")
if maximum_tableau([-27, 24, -3, 15]) == 24:
    print("Test n°2 : OK")
    c += 1
else :
    print("Test n°2 : échec")
if maximum_tableau([-27, -24, -3, -15]) == -3:
    print("Test n°3 : OK")
    c += 1
else :
    print("Test n°3 : échec")
if c == 3 :
    print('OK')
else :
    print('KO')
;;;
recherche
;;;
Programmer la fonction recherche, prenant en paramètres un tableau non vide tab (type list) d’entiers et un entier n, et qui renvoie l’indice de la première occurrence de l’élément cherché.
Si l’élément n’est pas présent, la fonction renvoie None.
Exemples
>>> recherche([5, 3],1) # renvoie None
>>> recherche([2,4],2)
0
>>> recherche([2,3,5,2,4],2)
0
;;;
c = 0
if recherche([5, 3],1) == None:
    print("Test n°1 : OK")
    c += 1
else :
    print("Test n°1 : échec")
if recherche([2,4],2) == 0:
    print("Test n°2 : OK")
    c += 1
else :
    print("Test n°2 : échec")
if recherche([2,3,5,2,4],2) == 0:
    print("Test n°3 : OK")
    c += 1
else :
    print("Test n°3 : échec")
if c == 3 :
    print('OK')
else :
    print('KO')
;;;
max_et_indice
;;;
Écrire une fonction max_et_indice qui prend en paramètre un tableau non vide tab (type Python list) de nombres entiers et qui renvoie la valeur du plus grand élément de ce tableau ainsi que l’indice de sa première apparition dans ce tableau.
L’utilisation de la fonction native max n’est pas autorisée.
Exemples :
>>> max_et_indice([1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
(9, 3)
>>> max_et_indice([-2])
(-2, 0)
>>> max_et_indice([-1, -1, 3, 3, 3])
(3, 2)
>>> max_et_indice([1, 1, 1, 1])
(1, 0)
;;;
c = 0
if max_et_indice([1, 5, 6, 9, 1, 2, 3, 7, 9, 8]) == (9,3):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if max_et_indice([-2]) == (-2, 0):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if max_et_indice([-1, -1, 3, 3, 3]) == (3, 2):
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if max_et_indice([1, 1, 1, 1]) == (1, 0):
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;
verifie
;;;
Écrire une fonction verifie qui prend en paramètre un tableau de valeurs numériques et qui renvoie True si ce tableau est trié dans l’ordre croissant, False sinon.
Un tableau vide est considéré comme trié.
Exemples :
>>> verifie([0, 5, 8, 8, 9])
True
>>> verifie([8, 12, 4])
False
>>> verifie([-1, 4])
True
>>> verifie([])
True
>>> verifie([5])
True
;;;
c = 0
if verifie([0, 5, 8, 8, 9]):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if not verifie([8, 12, 4]):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if verifie([-1, 4]):
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if verifie([]):
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if verifie([5]):
    print("Test 5 : OK")
    c += 1
else  :
    print("Test 5 : échec")
if c == 5 :
    print("OK")
else :
    print("KO")
;;;
delta encoding
;;;
Le codage par différence (delta encoding en anglais) permet de compresser un tableau d’entiers dont les valeurs sont proches les unes des autres. Le principe est de stocker la première donnée en indiquant pour chaque autre donnée sa différence avec la précédente plutôt que la donnée elle-même.
On se retrouve alors avec un tableau dont les valeurs sont plus petites, nécessitant moins de place en mémoire.
Programmer la fonction delta qui prend en paramètre un tableau non vide de nombres entiers et qui renvoie un tableau contenant les valeurs entières compressées à l’aide cette technique.
Exemples :
>>> delta([1000, 800, 802, 1000, 1003])
[1000, -200, 2, 198, 3]
>>> delta([42])
[42]
;;;
c = 0
if delta([1000, 800, 802, 1000, 1003]) == [1000, -200, 2, 198, 3]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if delta([42]) == [42]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
moyenne pondérée
;;;
Dans cet exercice, on cherche à calculer la moyenne pondérée d’un élève dans une matière donnée. Chaque note est associée à un coefficient qui la pondère. Par exemple, si ses notes sont : 14 avec coefficient 3, 12 avec coefficient 1 et 16 avec coefficient 2, sa moyenne pondérée sera donnée par :
(14 × 3 + 12 × 1 + 16 × 2) / (3 + 1 + 2) = 14, 333...
Écrire une fonction moyenne : qui prend en paramètre une liste notes non vide de tuples à deux éléments entiers de la forme (note, coefficient) (int ou float) positifs ou nuls et qui renvoie la moyenne pondérée des notes de la liste sous forme de flottant si la somme des coefficients est non nulle, None sinon.
Exemple :
>>> moyenne([(12, 2), (8, 1), (10, 1)])
10.5
>>> moyenne([(3, 0), (5, 0)])
None
;;;
c = 0
if moyenne([(12, 2), (8, 1), (10, 1)]) == 10.5:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if moyenne([(3, 0), (5, 0)]) == None:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
tri sélection
;;;
Écrire une fonction tri_selection qui prend en paramètre un tableau tab de nombres entiers (type list) et qui le modifie afin qu’il soit trié par ordre croissant.
Exemple :
>>> tri_selection([1, 52, 6, -9, 12])
[-9, 1, 6, 12, 52]
>>> tri_selection([6])
[6]
;;;
c = 0
if tri_selection([1, 52, 6, -9, 12]) == [-9, 1, 6, 12, 52]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if tri_selection([6]) == [6]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
min et max
;;;
Écrire une fonction min_et_max qui prend en paramètre un tableau de nombres tab non vide, et qui renvoie la plus petite et la plus grande valeur du tableau sous la forme d’un dictionnaire à deux clés min et max.
L’utilisation des fonctions natives min, max et sorted, ainsi que la méthode sort n’est pas autorisée.
Exemples :
>>> min_et_max([0, 1, 4, 2, -2, 9, 3, 1, 7, 1])
{'min': -2, 'max': 9}
>>> min_et_max([0, 1, 2, 3])
{'min': 0, 'max': 3}
>>> min_et_max([3])
{'min': 3, 'max': 3}
>>> min_et_max([1, 3, 2, 1, 3])
{'min': 1, 'max': 3}
>>> min_et_max([-1, -1, -1, -1, -1])
{'min': -1, 'max': -1}
;;;
c = 0
if min_et_max([0, 1, 4, 2, -2, 9, 3, 1, 7, 1]) == {'min': -2, 'max': 9}:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if min_et_max([0, 1, 2, 3]) == {'min': 0, 'max': 3}:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if min_et_max([3]) == {'min': 3, 'max': 3}:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if min_et_max([1, 3, 2, 1, 3]) == {'min': 1, 'max': 3}:
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if min_et_max([-1, -1, -1, -1, -1]) == {'min': -1, 'max': -1}:
    print("Test 5 : OK")
    c += 1
else  :
    print("Test 5 : échec")
if c == 5 :
    print("OK")
else :
    print("KO")
;;;
nombre de répétitions
;;;
Écrire une fonction Python appelée nb_repetitions qui prend en paramètres un élément elt et un tableau tab (type list) d’éléments du même type et qui renvoie le nombre de fois où l’élément apparaît dans le tableau.
Exemples :
>>> nb_repetitions(5, [2, 5, 3, 5, 6, 9, 5])
3
>>> nb_repetitions('A', ['B', 'A', 'B', 'A', 'R'])
2
>>> nb_repetitions(12, [1, 3, 7, 21, 36, 44])
0
;;;
c = 0
if  nb_repetitions(5, [2, 5, 3, 5, 6, 9, 5]) == 3:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if nb_repetitions('A', ['B', 'A', 'B', 'A', 'R']) == 2 :
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if nb_repetitions(12, [1, 3, 7, 21, 36, 44]) == 0:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
recherche motif
;;;
Écrire une fonction recherche_motif qui prend en paramètres une chaîne de caractères motif non vide et une chaîne de caractères texte et qui renvoie la liste des positions de motif dans texte. Si motif n’apparaît pas, la fonction renvoie une liste vide.
Exemples:
>>> recherche_motif("ab", "")
[]
>>> recherche_motif("ab", "cdcdcdcd")
[]
>>> recherche_motif("ab", "abracadabra")
[0, 7]
>>> recherche_motif("ab", "abracadabraab")
[0, 7, 11]
;;;
c = 0
if recherche_motif("ab", "") == []:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if recherche_motif("ab", "cdcdcdcd") == []:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if recherche_motif("ab", "abracadabra") == [0, 7]:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if recherche_motif("ab", "abracadabraab") == [0, 7, 11]:
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;
recherche indice classement
;;;
Écrire une fonction recherche_indices_classement qui prend en paramètres un entier elt et un tableau d’entiers tab représenté par une liste Python, et qui renvoie trois listes Python d’entiers:
• la première liste contient les indices des valeurs du tableau tab strictement inférieures à elt ;
• la deuxième liste contient les indices des valeurs du tableau tab égales à elt ;
• la troisième liste contient les indices des valeurs du tableau tab strictement supérieures à elt.
Exemples :
>>> recherche_indices_classement(3, [1, 3, 4, 2, 4, 6, 3, 0])
([0, 3, 7], [1, 6], [2, 4, 5])
>>> recherche_indices_classement(3, [1, 4, 2, 4, 6, 0])
([0, 2, 5], [], [1, 3, 4])
>>>recherche_indices_classement(3, [1, 1, 1, 1])
([0, 1, 2, 3], [], [])
>>> recherche_indices_classement(3, [])
([], [], [])
;;;
c = 0
if recherche_indices_classement(3, [1, 3, 4, 2, 4, 6, 3, 0]) == ([0, 3, 7], [1, 6], [2, 4, 5]):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if recherche_indices_classement(3, [1, 4, 2, 4, 6, 0]) == ([0, 2, 5], [], [1, 3, 4]):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if recherche_indices_classement(3, [1, 1, 1, 1]) == ([0, 1, 2, 3], [], []):
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if recherche_indices_classement(3, []) == ([], [], []):
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;
parcours largeur arbre (T)
;;;
Un arbre binaire est soit vide, représenté en Python par la valeur None, soit un nœud représenté par un triplet (g, x, d) où x est l’étiquette du nœud et g et d sont les sousarbres gauche et droit.
On souhaite écrire une fonction parcours_largeur qui prend en paramètre un arbre binaire et qui renvoie la liste des étiquettes des nœuds de l’arbre parcourus en largeur.
Exemples :
>>> parcours_largeur(( ( (None, 1, None), 2, (None, 3, None) ),4,( (None, 5, None), 6, (None, 7, None) ) ))
[4, 2, 6, 1, 3, 5, 7]
;;;
c = 0
if parcours_largeur(( ( (None, 1, None), 2, (None, 3, None) ),4,( (None, 5, None), 6, (None, 7, None) ) )) == [4, 2, 6, 1, 3, 5, 7]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
recherche minimum
;;;
Écrire une fonction recherche_min qui prend en paramètre un tableau de nombres tab, et qui renvoie l’indice de la première occurrence du minimum de ce tableau. Les tableaux seront représentés sous forme de liste Python.
Il est interdit d'utiliser les fonctions min et index de Python.
Exemples :
>>> recherche_min([5])
0
>>> recherche_min([2, 4, 1])
2
>>> recherche_min([5, 3, 2, 2, 4])
2
>>> recherche_min([-1, -2, -3, -3])
2
;;;
c = 0
if recherche_min([5]) == 0:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if recherche_min([2, 4, 1]) == 2:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if recherche_min([5, 3, 2, 2, 4]) == 2:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if recherche_min([-1, -2, -3, -3]) == 2:
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;
ajoute dictionnaire
;;;
Écrire une fonction ajoute_dictionnaires qui prend en paramètres deux dictionnaires d1 et d2 dont les clés et les valeurs associées sont des nombres et renvoie le dictionnaire d défini de la façon suivante :
• les clés de d sont celles de d1 et celles de d2 réunies ;
• si une clé est présente dans les deux dictionnaires d1 et d2, sa valeur associée dans le dictionnaire d est la somme de ses valeurs dans les dictionnaires d1 et d2 ;
• si une clé n’est présente que dans un des deux dictionnaires, sa valeur associée dans le dictionnaire d est la même que sa valeur dans le dictionnaire où elle est présente.
Exemples :
>>> ajoute_dictionnaires({1: 5, 2: 7}, {2: 9, 3: 11})
{1: 5, 2: 16, 3: 11}
>>> ajoute_dictionnaires({}, {2: 9, 3: 11})
{2: 9, 3: 11}
>>> ajoute_dictionnaires({1: 5, 2: 7}, {})
{1: 5, 2: 7}
;;;
c = 0
if ajoute_dictionnaires({1: 5, 2: 7}, {2: 9, 3: 11}) == {1: 5, 2: 16, 3: 11}:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if ajoute_dictionnaires({}, {2: 9, 3: 11}) == {2: 9, 3: 11}:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if ajoute_dictionnaires({1: 5, 2: 7}, {}) == {1: 5, 2: 7}:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
couples consecutifs
;;;
Écrire une fonction couples_consecutifs qui prend en paramètre un tableau de nombres entiers tab non vide (type list), et qui renvoie la liste Python (éventuellement vide) des couples d’entiers consécutifs successifs qu’il peut y avoir dans tab.
Exemples :
>>> couples_consecutifs([1, 4, 3, 5])
[]
>>> couples_consecutifs([1, 4, 5, 3])
[(4, 5)]
>>> couples_consecutifs([1, 1, 2, 4])
[(1, 2)]
>>> couples_consecutifs([7, 1, 2, 5, 3, 4])
[(1, 2), (3, 4)]
>>> couples_consecutifs([5, 1, 2, 3, 8, -5, -4, 7])
[(1, 2), (2, 3), (-5, -4)]
;;;
c = 0
if couples_consecutifs([1, 4, 3, 5]) == []:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if couples_consecutifs([1, 4, 5, 3]) == [(4, 5)]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if couples_consecutifs([1, 1, 2, 4]) == [(1, 2)]:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if couples_consecutifs([7, 1, 2, 5, 3, 4]) == [(1, 2), (3, 4)]:
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if couples_consecutifs([5, 1, 2, 3, 8, -5, -4, 7]) == [(1, 2), (2, 3), (-5, -4)]:
    print("Test 5 : OK")
    c += 1
else  :
    print("Test 5 : échec")
if c == 5 :
    print("OK")
else :
    print("KO")
;;;
suite fibonacci
;;;
On s’intéresse à la suite d’entiers définie par :
• la première valeur est égale à 0 ;
• la deuxième valeur est égale à 1 ;
• ensuite, chaque valeur est obtenue en faisant la somme des deux valeurs qui le précèdent.
La troisième valeur est donc 0+1 = 1, la quatrième est 1+2 = 3, la cinquième est 2+3 = 5, la sixième est 3 + 5 = 8, et ainsi de suite.
Cette suite d’entiers est connue sous le nom de suite de Fibonacci.
Écrire en Python une fonction fibonacci qui prend en paramètre un entier n supposé strictement positif et qui renvoie le terme d’indice n de cette suite.
Exemples :
>>> fibonacci(0)
0
>>> fibonacci(1)
1
>>> fibonacci(2)
1
>>> fibonacci(10)
55
>>> fibonacci(13)
233
;;;
c = 0
if fibonacci(0) == 0:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if fibonacci(1) == 1:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if fibonacci(10) == 55:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if fibonacci(13) == 233:
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;
fusion tableaux
;;;
Programmer la fonction fusion prenant en paramètres deux tableaux non vides tab1 et tab2 (type list) d’entiers, chacun dans l’ordre croissant, et renvoyant un tableau trié dans l’ordre croissant et contenant l’ensemble des valeurs de tab1 et tab2.
Exemples :
>>> fusion([3, 5], [2, 5])
[2, 3, 5, 5]
>>> fusion([-2, 4], [-3, 5, 10])
[-3, -2, 4, 5, 10]
>>> fusion([4], [2, 6])
[2, 4, 6]
>>> fusion([], [])
[]
>>> fusion([1, 2, 3], [])
[1, 2, 3]
;;;
c = 0
if fusion([3, 5], [2, 5]) == [2, 3, 5, 5]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if fusion([-2, 4], [-3, 5, 10]) == [-3, -2, 4, 5, 10]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if fusion([4], [2, 6]) == [2, 4, 6]:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if fusion([], []) == []:
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if fusion([1, 2, 3], []) == [1, 2, 3]:
    print("Test 5 : OK")
    c += 1
else  :
    print("Test 5 : échec")
if c == 5 :
    print("OK")
else :
    print("KO")
;;;
multiplication
;;;
Programmer la fonction multiplication qui prend en paramètres deux nombres entiers relatifs n1 et n2, et qui renvoie le produit de ces deux nombres.
Les seules opérations arithmétiques autorisées sont l’addition et la soustraction.
Exemples :
>>> multiplication(3, 5)
15
>>> multiplication(-4, -8)
32
>>> multiplication(-2, 6)
-12
>>> multiplication(-2, 0)
0
;;;
c = 0
if multiplication(3, 5) == 15:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if multiplication(-4, -8) == 32:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if multiplication(-2, 6) == -12:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if multiplication(-2, 0) == 0:
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if c == 4 :
    print("OK")
else :
    print("KO")
;;;
renverse chaine
;;;
Programmer une fonction renverse qui prend en paramètre une chaîne de caractères mot et qui renvoie cette chaîne de caractères en ordre inverse.
Exemple :
>>> renverse("")
""
>>> renverse("abc")
"cba"
>>> renverse("informatique")
"euqitamrofni"
;;;
c = 0
if renverse("") == "":
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if renverse("abc") == "cba":
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if renverse("informatique") == "euqitamrofni":
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
nombre d’occurrences d’un caractère
;;;
Le nombre d’occurrences d’un caractère dans une chaîne de caractères est le nombre d’apparitions de ce caractère dans la chaîne.
Exemples :
• le nombre d’occurrences du caractère 'o' dans 'bonjour' est 2 ;
• le nombre d’occurrences du caractère 'b' dans 'Bébé' est 1 ;
• le nombre d’occurrences du caractère 'B' dans 'Bébé' est 1 ;
• le nombre d’occurrences du caractère ' ' dans 'Hello world !' est 2.
On cherche les occurrences des caractères dans une phrase. On souhaite stocker ces occurrences dans un dictionnaire dont les clefs seraient les caractères de la phrase et les valeurs le nombre d’occurrences de ces caractères.
Par exemple : avec la phrase 'Hello world !' le dictionnaire est le suivant :

{'H': 1,'e': 1,'l': 3,'o': 2,' ': 2,'w': 1,'r': 1,'d': 1,'!': 1}

L’ordre des clefs n’a pas d’importance.
Écrire une fonction nbr_occurrences prenant comme paramètre une chaîne de caractères chaine et renvoyant le dictionnaire des nombres d’occurrences des caractères de cette chaîne.
;;;
c = 0
if nbr_occurrences('Hello world !') == {'H': 1,'e': 1,'l': 3,'o': 2,' ': 2,'w': 1,'r': 1,'d': 1,'!': 1}:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
temperature minimale
;;;
On a relevé les valeurs moyennes annuelles des températures à Paris pour la période allant de 2013 à 2019. Les résultats ont été récupérés sous la forme de deux tableaux (de type list) : l’un pour les températures, l’autre pour les années :

t_moy = [14.9, 13.3, 13.1, 12.5, 13.0, 13.6, 13.7]
annees = [2013, 2014, 2015, 2016, 2017, 2018, 2019]

Écrire la fonction annee_temperature_minimale qui prend en paramètres ces deux tableaux et qui renvoie la plus petite valeur relevée au cours de la période et l’année correspondante.
On suppose que la température minimale est atteinte une seule fois.
Exemple :
>>> annee_temperature_minimale(t_moy, annees)
(12.5, 2016)
;;;
c = 0
if annee_temperature_minimale([14.9, 13.3, 13.1, 12.5, 13.0, 13.6, 13.7], [2013, 2014, 2015, 2016, 2017, 2018, 2019]) == (12.5, 2016):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if c == 1 :
    print("OK")
else :
    print("KO")
;;;
occurrences
;;;
Écrire une fonction occurrences(caractere, chaine) qui prend en paramètres caractere, une chaîne de caractère de longueur 1, et chaine, une chaîne de caractères.
Cette fonction renvoie le nombre d’occurrences de caractere dans chaine, c’est-à-dire le nombre de fois où caractere apparaît dans chaine.
Exemples :
>>> occurrences('e', "sciences")
2
>>> occurrences('i',"mississippi")
4
>>> occurrences('a',"mississippi")
0
;;;
c = 0
if occurrences('e', "sciences") == 2:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if occurrences('i',"mississippi") == 4:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if occurrences('a',"mississippi") == 0:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
indices maxi
;;;
Écrire une fonction indices_maxi qui prend en paramètre un tableau non vide de nombres entiers tab, représenté par une liste Python et qui renvoie un tuple (maxi, indices) où :
• maxi est le plus grand élément du tableau tab ;
• indices est une liste Python contenant les indices du tableau tab où apparaît ce plus grand élément.
Exemple :
>>> indices_maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8])
(9, [3, 8])
>>> indices_maxi([7])
(7, [0])
;;;
c = 0
if indices_maxi([1, 5, 6, 9, 1, 2, 3, 7, 9, 8]) == (9, [3, 8]):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if indices_maxi([7]) == (7, [0]):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;
sélection enclos
;;;
On considère des tables, c’est-à-dire des tableaux de dictionnaires ayant tous les mêmes clés, qui contiennent des enregistrements relatifs à des animaux hébergés dans un refuge. Les attributs des enregistrements sont 'nom', 'espece', 'age', 'enclos'.
Voici un exemple d’une telle 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}]
Programmer une fonction selection_enclos qui :
prend en paramètres : une table animaux contenant des enregistrements relatifs à des animaux (comme dans l’exemple ci-dessus) et un numéro d’enclos num_enclos ;
La fonction renvoie une table contenant les enregistrements de animaux dont l’attribut 'enclos' est num_enclos.
Exemples avec la table animaux ci-dessus :
>>> selection_enclos(animaux, 5)
[{'nom':'Titine', 'espece':'chat', 'age':2, 'enclos':5},
{'nom':'Mirza', 'espece':'chat', 'age':6, 'enclos':5}]
>>> selection_enclos(animaux, 2)
[{'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2}]
>>> selection_enclos(animaux, 7)
[]
;;;
c = 0
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}]
if selection_enclos(animaux, 5)== [{'nom':'Titine', 'espece':'chat', 'age':2, 'enclos':5}, {'nom':'Mirza', 'espece':'chat', 'age':6, 'enclos':5}]:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if selection_enclos(animaux, 2) == [{'nom':'Medor', 'espece':'chien', 'age':5, 'enclos':2}]:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if  selection_enclos(animaux, 7) == []:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
doublon
;;;
Écrire une fonction a_doublon qui prend en paramètre un tableau trié de nombres dans l’ordre croissant et renvoie True si ce tableau contient au moins deux nombres identiques, False sinon.
Exemple :
>>> a_doublon([])
False
>>> a_doublon([1])
False
>>> a_doublon([1, 2, 4, 6, 6])
True
>>> a_doublon([2, 5, 7, 7, 7, 9])
True
>>> a_doublon([0, 2, 3])
False
;;;c = 0
if not a_doublon([]):
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if not a_doublon([1]):
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if a_doublon([1, 2, 4, 6, 6]):
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if a_doublon([2, 5, 7, 7, 7, 9]):
    print("Test 4 : OK")
    c += 1
else  :
    print("Test 4 : échec")
if not a_doublon([0, 2, 3]):
    print("Test 5 : OK")
    c += 1
else  :
    print("Test 5 : échec")
if c == 5 :
    print("OK")
else :
    print("KO")
;;;
énumère
;;;
Écrire unefonctionenumerequi prend en paramètre un tableautab(typelist) et renvoie un dictionnaire d dont les clés sont les éléments de tab avec pour valeur associée la liste des indices de l’élément dans le tableau tab.
Exemple :
>>> enumere([])
{}
>>> enumere([1, 2, 3])
{1: [0], 2: [1], 3: [2]}
>>> enumere([1, 1, 2, 3, 2, 1])
{1: [0, 1, 5], 2: [2, 4], 3: [3]}
;;;
c = 0
if enumere([])== {}:
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if enumere([1, 2, 3]) == {1: [0], 2: [1], 3: [2]}:
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if  enumere([1, 1, 2, 3, 2, 1]) == {1: [0, 1, 5], 2: [2, 4], 3: [3]}:
    print("Test 3 : OK")
    c += 1
else  :
    print("Test 3 : échec")
if c == 3 :
    print("OK")
else :
    print("KO")
;;;
max_dico
;;;
Sur le réseau social TipTop, on s’intéresse au nombre de « like » des abonnés. Les données sont stockées dans des dictionnaires où les clés sont les pseudos et les valeurs correspondantes sont les nombres de « like » comme ci-dessous :

{ 'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50 }

Écrire une fonction max_dico qui :
• prend en paramètre un dictionnaire dico non vide dont les clés sont des chaînes de caractères et les valeurs associées sont des entiers ;
• et qui renvoie un tuple dont :
– la première valeur est une clé du dictionnaire associée à la valeur maximale ;
– la seconde valeur est cette valeur maximale.
Exemples :
>>> max_dico({ 'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50 })
('Ada', 201)
>>> max_dico({ 'Alan': 222, 'Ada': 201, 'Eve': 222, 'Tim': 50 })
('Alan', 222) # ou ('Eve', 222) également possible
;;;
c = 0
if max_dico({ 'Bob': 102, 'Ada': 201, 'Alice': 103, 'Tim': 50 }) == ('Ada', 201) :
    print("Test 1 : OK")
    c += 1
else  :
    print("Test 1 : échec")
if max_dico({ 'Alan': 222, 'Ada': 201, 'Eve': 222, 'Tim': 50 }) == ('Alan', 222) or ('Eve', 222) :
    print("Test 2 : OK")
    c += 1
else  :
    print("Test 2 : échec")
if c == 2 :
    print("OK")
else :
    print("KO")
;;;