Upload code.txt

code.txt

@@ -1,4 +1,4 @@
-moyenne
+moyenne (N2)
 ;;;
 É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
@@ -24,7 +24,7 @@ if c == 2 :
 else :
     print('KO')
 ;;;
-maximum_tableau
+maximum_tableau (N2)
 ;;;
 É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
@@ -55,7 +55,7 @@ if c == 3 :
 else :
     print('KO')
 ;;;
-recherche
+recherche (N2)
 ;;;
 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.
@@ -87,7 +87,7 @@ if c == 3 :
 else :
     print('KO')
 ;;;
-max_et_indice
+max_et_indice (N2)
 ;;;
 É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.
@@ -127,7 +127,7 @@ if c == 4 :
 else :
     print("KO")
 ;;;
-verifie
+verifie (N3)
 ;;;
 É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é.
@@ -174,7 +174,7 @@ if c == 5 :
 else :
     print("KO")
 ;;;
-delta encoding
+delta encoding (N3)
 ;;;
 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.
@@ -201,7 +201,7 @@ if c == 2 :
 else :
     print("KO")
 ;;;
-moyenne pondérée
+moyenne pondérée (N3)
 ;;;
 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...
@@ -228,9 +228,9 @@ if c == 2 :
 else :
     print("KO")
 ;;;
-tri sélection
+tri sélection (N3)
 ;;;
-É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.
+Écrire une fonction tri_selection qui prend en paramètre un tableau tab de nombres entiers (type list) et qui renvoie un tableau trié par ordre croissant. Cette fonction doit utiliser l'algorithme du tri sélection
 Exemple :
 >>> tri_selection([1, 52, 6, -9, 12])
 [-9, 1, 6, 12, 52]
@@ -253,7 +253,7 @@ if c == 2 :
 else :
     print("KO")
 ;;;
-min et max
+min et max (N2)
 ;;;
 É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.
@@ -300,7 +300,7 @@ if c == 5 :
 else :
     print("KO")
 ;;;
-nombre de répétitions
+nombre de répétitions (N2)
 ;;;
 É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 :
@@ -332,7 +332,7 @@ if c == 3 :
 else :
     print("KO")
 ;;;
-recherche motif
+recherche motif (N3)
 ;;;
 É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:
@@ -371,7 +371,7 @@ if c == 4 :
 else :
     print("KO")
 ;;;
-recherche indice classement
+recherche indice classement (N3)
 ;;;
 É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 ;
@@ -413,7 +413,7 @@ if c == 4 :
 else :
     print("KO")
 ;;;
-parcours largeur arbre (T)
+parcours largeur arbre (N3 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.
@@ -432,7 +432,7 @@ if c == 1 :
 else :
     print("KO")
 ;;;
-recherche minimum
+recherche minimum (N2)
 ;;;
 É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.
@@ -472,7 +472,7 @@ if c == 4 :
 else :
     print("KO")
 ;;;
-ajoute dictionnaire
+ajoute dictionnaire (N3)
 ;;;
 É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 ;
@@ -507,7 +507,7 @@ if c == 3 :
 else :
     print("KO")
 ;;;
-couples consecutifs
+couples consecutifs (N3)
 ;;;
 É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 :
@@ -553,7 +553,24 @@ if c == 5 :
 else :
     print("KO")
 ;;;
-suite fibonacci
+moyenne (N1)
+;;;
+Écrire une fonction moyenne qui prend en paramètre 3 entiers a, b et c. Cette fonction renvoie la moyenne des entiers a, b et c.
+>>> moyenne(5, 10, 15)
+10
+;;;
+c = 0
+if moyenne(5, 10, 15) == 10:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if c == 1 :
+    print("OK")
+else :
+    print("KO")
+;;;
+suite fibonacci (N3)
 ;;;
 On s’intéresse à la suite d’entiers définie par :
 • la première valeur est égale à 0 ;
@@ -600,7 +617,7 @@ if c == 4 :
 else :
     print("KO")
 ;;;
-fusion tableaux
+fusion tableaux (N3)
 ;;;
 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 :
@@ -646,7 +663,7 @@ if c == 5 :
 else :
     print("KO")
 ;;;
-multiplication
+multiplication (N4)
 ;;;
 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.
@@ -686,7 +703,7 @@ if c == 4 :
 else :
     print("KO")
 ;;;
-renverse chaine
+renverse chaine (N3)
 ;;;
 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 :
@@ -718,7 +735,7 @@ if c == 3 :
 else :
     print("KO")
 ;;;
-nombre d’occurrences d’un caractère
+nombre d’occurrences d’un caractère (N3)
 ;;;
 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 :
@@ -745,7 +762,7 @@ if c == 1 :
 else :
     print("KO")
 ;;;
-temperature minimale
+temperature minimale (N3)
 ;;;
 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 :
 
@@ -769,7 +786,7 @@ if c == 1 :
 else :
     print("KO")
 ;;;
-occurrences
+occurrences (N2)
 ;;;
 É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.
@@ -802,7 +819,26 @@ if c == 3 :
 else :
     print("KO")
 ;;;
-indices maxi
+aire cercle (N1)
+;;;
+Écrire une fonction aire_cercle qui prend en paramètre le rayon d'un cercle r et qui renvoie l'aire du cercle.
+Exemple :
+>>> aire_cercle(2)
+28.274
+;;;
+c = 0
+import math
+if round(aire_cercle(3)) == 28:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if c == 1 :
+    print("OK")
+else :
+    print("KO")
+;;;
+indices maxi (N2)
 ;;;
 É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 ;
@@ -829,7 +865,25 @@ if c == 2 :
 else :
     print("KO")
 ;;;
-sélection enclos
+addition (N1)
+;;;
+Écrire une fonction add qui prend en paramètre 2 entiers a et b. Cette fonction renvoie l'addition de a et b.
+Exemple :
+>>> add(3, 5)
+8
+;;;
+c = 0
+if add(3,5) == 8:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if c == 1 :
+    print("OK")
+else :
+    print("KO")
+;;;
+sélection enclos (N3)
 ;;;
 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 :
@@ -868,7 +922,31 @@ if c == 3 :
 else :
     print("KO")
 ;;;
-doublon
+pair (N1)
+;;;
+Écrire une fonction pair qui prend en paramètre un entier n. Cette fonction renvoie True si n est pair et False si n est impair.
+>>> pair(8)
+True
+>>> pair(5)
+False
+;;;
+c = 0
+if pair(8):
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if not pair(5):
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;
+doublon (N2)
 ;;;
 É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 :
@@ -914,9 +992,35 @@ if c == 5 :
 else :
     print("KO")
 ;;;
-énumère
+somme (N2)
+;;;
+Écrire une fonction somme qui prend en paramètre un tableau d'entiers tab (de type list). Cette fonction renvoie la somme des éléments présents dans tab.
+Il est interdit d'utiliser la fonction Python sum.
+Exemples :
+>>> somme([5, 4, 7])
+16
+>>> somme([])
+0
+;;;
+c = 0
+if somme([5, 4, 7]) == 16:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if somme([]) == 0:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;
+énumère (N3)
 ;;;
-Écrire une fonctionenumerequi 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.
+Écrire une fonction enumere qui prend en paramètre un tableau tab (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([])
 {}
@@ -946,7 +1050,7 @@ if c == 3 :
 else :
     print("KO")
 ;;;
-max_dico
+max_dico (N3)
 ;;;
 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 :
 
@@ -979,3 +1083,437 @@ if c == 2 :
 else :
     print("KO")
 ;;;
+correspond (N3)
+;;;
+On considère des chaînes de caractères contenant uniquement des majuscules et des caractères * appelées mots à trous.
+Par exemple INFO*MA*IQUE, ***I***E** et *S* sont des mots à trous.
+Programmer une fonction correspond :
+• qui prend en paramètres deux chaînes de caractères mot et mot_a_trous où mot_a_trous est un mot à trous comme indiqué ci-dessus ;
+• et qui renvoie :
+– True si on peut obtenir mot en remplaçant convenablement les caractères '*' de mot_a_trous ;
+– False sinon.
+Exemple :
+>>> correspond('INFORMATIQUE', 'INFO*MA*IQUE')
+True
+>>> correspond('AUTOMATIQUE', 'INFO*MA*IQUE')
+False
+>>> correspond('STOP', 'S*')
+False
+>>> correspond('AUTO', '*UT*')
+True
+;;;
+c = 0
+if correspond('INFORMATIQUE', 'INFO*MA*IQUE') :
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if not correspond('AUTOMATIQUE', 'INFO*MA*IQUE') :
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if not correspond('STOP', 'S*') :
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if correspond('AUTO', '*UT*') :
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if c == 4 :
+    print("OK")
+else :
+    print("KO")
+;;;
+tri insertion (N3)
+;;;
+Écrire une fonction tri_insertion qui prend en paramètre un tableau tab de nombres entiers (type list) et qui renvoie un tableau trié par ordre croissant. Cette fonction doit utiliser l'algorithme du tri par insertion.
+Exemple :
+>>> tri_insertion([1, 52, 6, -9, 12])
+[-9, 1, 6, 12, 52]
+>>> tri_insertion([6])
+[6]
+;;;
+c = 0
+if tri_insertion([1, 52, 6, -9, 12]) == [-9, 1, 6, 12, 52]:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if tri_insertion([6]) == [6]:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;
+insére (N3)
+;;;
+On considère la fonction insere ci-dessous qui prend en arguments un tableau tab d’entiers triés par ordre croissant et un entier a.
+Cette fonction crée et renvoie un nouveau tableau à partir de celui fourni en paramètre en y insérant la valeur a de sorte que le tableau renvoyé soit encore trié par ordre croissant. Les tableaux seront représentés sous la forme de listes Python.
+Écrire cette fonction insere
+Exemples :
+>>> insere([1, 2, 4, 5], 3)
+[1, 2, 3, 4, 5]
+>>> insere([1, 2, 7, 12, 14, 25], 30)
+[1, 2, 7, 12, 14, 25, 30]
+>>> insere([2, 3, 4], 1)
+[1, 2, 3, 4]
+>>> insere([], 1)
+[1]
+;;;
+c = 0
+if insere([1, 2, 4, 5], 3) ==  [1, 2, 3, 4, 5]:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if insere([1, 2, 7, 12, 14, 25], 30) ==  [1, 2, 7, 12, 14, 25, 30]:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if insere([2, 3, 4], 1) ==  [1, 2, 3, 4]:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if insere([], 1) == [1] :
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if c == 4 :
+    print("OK")
+else :
+    print("KO")
+;;;
+décimal vers binaire (N3)
+;;;
+On considère la fonction binaire. Cette fonction prend en paramètre un entier positif a en écriture décimale et renvoie son écriture binaire sous la forme d’une chaine de caractères.
+Écrire cette fonction binaire
+Exemples :
+>>> binaire(83)
+'1010011'
+>>> binaire(6)
+'110'
+>>> binaire(127)
+'1111111'
+>>> binaire(0)
+'0'
+;;;
+c = 0
+if binaire(83) ==  '1010011':
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if binaire(6) ==  '110':
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if binaire(127) ==  '1111111':
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if binaire(0) == '0' :
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if c == 4 :
+    print("OK")
+else :
+    print("KO")
+;;;
+recherche dichotomique récursive (N3 T)
+;;;
+Soit tab un tableau non vide d’entiers triés dans l’ordre croissant et n un entier.
+La fonction chercher doit renvoyer l'indice de position de n dans le dernier s'il s'y trouve et None s'il est absent du tableau
+La fonction recherche prend n en paramètre
+L’algorithme demandé est une recherche dichotomique récursive.
+Écrire le code de la fonction chercher.
+
+Exemples :
+>>> chercher([1, 5, 6, 9, 12], 7)
+>>> chercher([1, 5, 6, 9, 12], 9)
+4
+>>> chercher([1, 5, 6, 9, 12], 6)
+2
+;;;
+c = 0
+if chercher([1, 5, 6, 9, 12], 7) == None:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if chercher([1, 5, 6, 9, 12], 9) ==  4:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if chercher([1, 5, 6, 9, 12], 6) ==  2:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if c == 3 :
+    print("OK")
+else :
+    print("KO")
+;;;
+moyenne dico (N3)
+;;;
+Une professeure de NSI décide de gérer les résultats de sa classe sous la forme d’un dictionnaire :
+• les clefs sont les noms des élèves ;
+• les valeurs sont des dictionnaires dont les clefs sont les types d’épreuves sous forme de chaîne de caractères et les valeurs sont les notes obtenues associées à leurs coefficients dans une liste.
+Avec :
+resultats = {
+    Dupont': {
+        'DS1': [15.5, 4],
+        'DM1': [14.5, 1],
+        'DS2': [13, 4],
+        'PROJET1': [16, 3],
+        'DS3': [14, 4]
+    },
+    'Durand': {
+        'DS1': [6 , 4],
+        'DS2': [8, 4],
+        'PROJET1': [9, 3],
+        'IE1': [7, 2],
+        'DS3': [12, 4]
+    }
+}
+L’élève dont le nom est Durand a ainsi obtenu au DS2 la note de 8 avec un coefficient 4. La professeure crée une fonction moyenne qui prend en paramètre le nom d’un de ses élèves et renvoie sa moyenne arrondie au dixième. Si l’élève n’a pas de notes, on considère que sa moyenne est nulle. Si le nom donné n’est pas dans les résultats, la fonction renvoie None.
+Écrire le code de la fonction moyenne.
+Exemples :
+>>> moyenne("Dupont", resultats)
+14.5
+>>> moyenne("Durand", resultats)
+8.5
+;;;
+c = 0
+resultats = {'Dupont': {'DS1': [15.5, 4],'DM1': [14.5, 1],'DS2': [13, 4],'PROJET1': [16, 3],'DS3': [14, 4]},'Durand': {'DS1': [6 , 4],'DS2': [8, 4],'PROJET1': [9, 3],'IE1': [7, 2],'DS3': [12, 4]}}
+if  moyenne("Dupont", resultats) == 14.5:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if  moyenne("Durand", resultats) ==  8.5:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;
+ nombre de boites (N4)
+;;;
+On dispose d’un ensemble d’objets dont on connaît, pour chacun, la masse. On souhaite ranger l’ensemble de ces objets dans des boites identiques de telle manière que la somme des masses des objets contenus dans une boîte ne dépasse pas la capacité c de la boîte. On souhaite utiliser le moins de boîtes possibles pour ranger cet ensemble d’objets.
+Pour résoudre ce problème, on utilisera un algorithme glouton consistant à placer chacun des objets dans la première boîte où cela est possible.
+Par exemple, pour ranger dans des boîtes de capacité c = 5 un ensemble de trois objets dont les masses sont représentées en Python par la liste [1, 5, 2], on procède de la façon suivante :
+• Le premier objet, de masse 1, va dans une première boite.
+• Le deuxième objet, de masse 5, ne peut pas aller dans la même boite que le premier objet car cela dépasserait la capacité de la boite. On place donc cet objet dans une deuxième boîte.
+• Le troisième objet, de masse 2, va dans la première boîte.
+On a donc utilisé deux boîtes de capacité c = 5 pour ranger les 3 objets.
+Écrire la fonction Python empaqueter qui prend en paramètre la liste des masses liste_masses et la capacité de la boite c. La fonction empaqueter doit renvoiyer le nombre de boîtes de capacité c nécessaires pour empaqueter un ensemble
+d’objets dont les masses sont contenues dans la liste liste_masses. On supposera que toutes les masses sont inférieures ou égales à c.
+Exemples :
+>>> empaqueter([1, 2, 3, 4, 5], 10)
+2
+>>> empaqueter([1, 2, 3, 4, 5], 5)
+4
+>>> empaqueter([7, 6, 3, 4, 8, 5, 9, 2], 11)
+5
+;;;
+c = 0
+if empaqueter([1, 2, 3, 4, 5], 10) == 2:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if empaqueter([1, 2, 3, 4, 5], 5) == 4
+    c += 1
+else  :
+    print("Test 2 : échec")
+if empaqueter([7, 6, 3, 4, 8, 5, 9, 2], 11) ==  5:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if c == 3 :
+    print("OK")
+else :
+    print("KO")
+;;;
+plus grande somme (N4 T)
+;;;
+On considère un tableau non vide de nombres entiers, positifs ou négatifs, et on souhaite déterminer la plus grande somme possible de ses éléments consécutifs.
+Par exemple, dans le tableau [1, -2, 3, 10, -4, 7, 2, -5], la plus grande somme est 18 obtenue en additionnant les éléments 3, 10, -4, 7, 2.
+Pour cela, on va résoudre le problème par programmation dynamique. Si on note tab le tableau considéré et i un indice dans ce tableau, on se ramène à un problème plus simple : déterminer la plus grande somme possible de ses éléments consécutifs se terminant à l’indice i.
+Si on connait la plus grande somme possible de ses éléments consécutifs se terminant à l’indice i-1, on peut déterminer la plus grande somme possible de ses éléments consécutifs se terminant à l’indice i :
+• soit on obtient une plus grande somme en ajoutant tab[i] à cette somme précédente ;
+• soit on commence une nouvelle somme à partir de tab[i].
+Remarque : les sommes considérées contiennent toujours au moins un terme.
+Écrire la fonction somme_max qui prend en paramètre un tableau (de type list) et qui renvoie la plus grande somme possible des éléments consécutifs.
+Exemples :
+>>> somme_max([1, 2, 3, 4, 5])
+15
+>>> somme_max([1, 2, -3, 4, 5])
+9
+>>> somme_max([1, 2, -2, 4, 5])
+10
+>>> somme_max([1, -2, 3, 10, -4, 7, 2, -5])
+18
+>>> somme_max([-3,-2,-1,-4])
+-1
+;;;
+c = 0
+if somme_max([1, 2, 3, 4, 5]) ==  15:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if somme_max([1, 2, -3, 4, 5]) ==  9:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if somme_max([1, 2, -2, 4, 5]) ==  10:
+    print("Test 3 : OK")
+    c += 1
+else  :
+    print("Test 3 : échec")
+if somme_max([1, -2, 3, 10, -4, 7, 2, -5]) == 18 :
+    print("Test 4 : OK")
+    c += 1
+else  :
+    print("Test 4 : échec")
+if omme_max([-3,-2,-1,-4]) == -1 :
+    print("Test 5 : OK")
+    c += 1
+else  :
+    print("Test 5 : échec")
+if c == 5 :
+    print("OK")
+else :
+    print("KO")
+;;;
+sépare 0 et 1 (N3)
+;;;
+Écrire la fonction separe qui prend en paramètre un tableau tab dont les éléments sont des 0 et des 1. Cette fonction renvoie un tableau qui contient autant de 0 et de 1 qu'il y en a dans tab mais où tous les 0 sont placés en début de tableau et tous les 1 sont placés en fin de tableau.
+Exemples :
+>>> separe([1, 0, 1, 0, 1, 0, 1, 0])
+[0, 0, 0, 0, 1, 1, 1, 1]
+>>> separe([1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0])
+[0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]
+;;;
+c = 0
+if separe([1, 0, 1, 0, 1, 0, 1, 0])) ==  [0, 0, 0, 0, 1, 1, 1, 1]:
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if separe([1, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1, 1, 0]) ==  [0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1]:
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;
+élève du mois (N3)
+;;;
+On considère la fonction eleves_du_mois prenant en paramètres eleves et notes deux tableaux de même longueur, le premier contenant le nom des élèves et le second, des entiers positifs désignant leur note à un contrôle de sorte que eleves[i] a obtenu la note notes[i].
+Cette fonction renvoie le couple constitué de la note maximale attribuée et des noms des élèves ayant obtenu cette note regroupés dans un tableau.
+Écrire la fonction eleves_du_mois.
+Exemples :
+>>> eleves_nsi = ['a','b','c','d','e','f','g','h','i','j']
+>>> notes_nsi = [30, 40, 80, 60, 58, 80, 75, 80, 60, 24]
+>>> eleves_du_mois(eleves_nsi, notes_nsi)
+(80, ['c', 'f', 'h'])
+>>> eleves_du_mois([],[])
+(0, [])
+;;;
+c = 0
+eleves_nsi = ['a','b','c','d','e','f','g','h','i','j']
+notes_nsi = [30, 40, 80, 60, 58, 80, 75, 80, 60, 24]
+if eleves_du_mois(eleves_nsi, notes_nsi) ==  (80, ['c', 'f', 'h']):
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if eleves_du_mois([],[]) ==  (0, []):
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;
+recherche dichotomique (N2)
+;;;
+Écrire une fonction dichotomie qui prend en paramètre un tableau tab d'entiers triés et un entier n. Cette fonction renvoie True si n est présent dans le tableau et False dans le cas contraire.
+Attention : vous devez utiliser l'algorithme de la recherche dichotomique
+Exemples :
+>>> dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],28)
+True
+>>> dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],27)
+False
+;;;
+c = 0
+if dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],28):
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if not dichotomie([15, 16, 18, 19, 23, 24, 28, 29, 31, 33],27):
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;
+palindrome (N3)
+;;;
+Un mot palindrome peut se lire de la même façon de gauche à droite ou de droite à gauche : kayak, radar, et non sont des mots palindromes.
+Écrire une fonction est_palidrome qui prend en paramètre une chaine de caractère mot. Cette fonction renvoie True si mot est un palindrome et False dans le cas contraire.
+Exemples :
+>>> est_palindrome('kayak')
+True
+>>> est_palindrome('NSI')
+False
+;;;
+c = 0
+if est_palindrome('kayak'):
+    print("Test 1 : OK")
+    c += 1
+else  :
+    print("Test 1 : échec")
+if not est_palindrome('NSI'):
+    print("Test 2 : OK")
+    c += 1
+else  :
+    print("Test 2 : échec")
+if c == 2 :
+    print("OK")
+else :
+    print("KO")
+;;;