diff --git a/TD01/code/04-bases.py b/TD01/code/04-bases.py
deleted file mode 100644
index 12652e49dabfc5af5f65e54fd55b77215c052114..0000000000000000000000000000000000000000
--- a/TD01/code/04-bases.py
+++ /dev/null
@@ -1,38 +0,0 @@
-# Exemple 1 : moyenne
-# Calcul de la moyenne de deux entiers
-
-a=input('Donner la valeur de a : ')
-b=input('Donner la valeur de b : ')
-print('la moyenne = ', (int(a) + int(b))/2) # int(a) : conversion de 'a' en entier
-
-# Une seconde méthode : on convertit en lisant les valeurs en int
-a=int(input('Donner la valeur de a : '))
-b=int(input('Donner la valeur de b : '))
-print('la moyenne = ', (a+b)/2)
-
-# Exemple 2 : racines carrées
-import math;
-
-a=int(input('Donner le coefficient a : '))
-b=int(input('Donner le coefficient b : '))
-c=int(input('Donner le coefficient c : '))
-
-if (a == 0):
- if ( b != 0) :
- print("Pas quadratique : racine simple x = ",-c/b)
- else:
- print("une blague ! ")
-else :
- delta=b*b-4*a*c #ou b**2
- if(delta < 0) :
- print("pas de racines reelles")
- else :
- assert(a != 0) # Déjà vérifié mais pour montrer l'intérêt de "assert".
- if(delta>0) :
- x1 = (-b+math.sqrt(delta))/(2*a)
- x2 = (-b-math.sqrt(delta))/(2*a)
- print("x1 = ",x1)
- print("x2 = ",x2)
- else :
- x1 = x2 = -b/(2*a)
- print("racine double x1 = x2 = ",x1)
\ No newline at end of file
diff --git a/TD01/code/05-fonctions.py b/TD01/code/05-fonctions.py
deleted file mode 100644
index 76267678416ac268d6a55863a93bf3698c63db87..0000000000000000000000000000000000000000
--- a/TD01/code/05-fonctions.py
+++ /dev/null
@@ -1,11 +0,0 @@
-# 5 Introduction aux fonctions
-
-## Exemple : moyenne de deux entiers
-# Calcul de la moyenne de deux entiers par une fonction (de signature entier x entier -> reel)
-def moyenne(a,b):
- return (a+b)/2
-
-# --- Partie Principale ----
-a=input('Donner la valeur de a : ')
-b=input('Donner la valeur de b : ')
-print('la moyenne = ', moyenne(int(a),int(b)))
\ No newline at end of file
diff --git a/TD01/code/05-fonctions_exercices.py b/TD01/code/05-fonctions_exercices.py
deleted file mode 100644
index 0be4025eee77488ccc7c28d2bd07072fb4cf1eef..0000000000000000000000000000000000000000
--- a/TD01/code/05-fonctions_exercices.py
+++ /dev/null
@@ -1,68 +0,0 @@
-## 5.2 Exercice : Racines d'une quadratique avec une fonction
-# Reprendre l'exemple du calcul des racines d'une équation de seconde degré
-# et placer les calculs dans la fonction {\tt quadratique(a, b, c)} qui
-# reçoit en paramètre les coefficients {\it a,b} et {\it c} et renvoie les
-# racines de cette équation.
-
-from math import sqrt
-
-def quadratique(a, b, c):
- if (a == 0):
- if ( b != 0) :
- return ("Pas quadratique : racine simple x "+str(-c/b))
- else:
- return ("une blague ! ")
- else :
- delta=b*b-4*a*c #b*b OU b**2
- if(delta < 0) :
- return ("pas de racines réelles")
- else :
- if(delta>0) : # Le test initial sur la valeur de "a" montre son intérêt ici.
- assert(a != 0) # Pas utile mais on montre aux élèves l'intérêt de "assert".
- x1=(-b+math.sqrt(delta))/(2*a)
- x2=(-b-math.sqrt(delta))/(2*a)
- return ("x1 = "+str(x1)+ " x2 = "+ str(x2))
- else :
- x1 = x2 = -b/(2*a)
- return ("racine double x1 = x2 = "+str(x1))
-
-# La partie principale
-a=int(input('Donner le coefficient a : '))
-b=int(input('Donner le coefficient b : '))
-c=int(input('Donner le coefficient c : '))
-print(quadratique(a,b,c))
-
-## 5.3 Exercice : Moyenne et écart type
-# Créer une liste de 100 nombres de la distribution N(16,2).
-import random
-echantillon=[random.gauss(16,2) for n in range(100)]
-
-def moyenne_liste(liste):
- return sum(liste)/len(liste)
-
-def variance(liste):
- moy=moyenne_liste(liste)
- return moyenne_liste([(x-moy)**2 for x in liste])
-
-# ---------- Partie Principale ----------
-# Pour tester nos calculs sans lire des entiers, on fait un tirage Normale
-echantillon=[random.gauss(16,2) for n in range(100)]
-
-print("Moyenne = " , moyenne_liste(echantillon))
-print("Ecart type = " , variance(echantillon)**0.5) # %* {\color{magenta} $\sqrt{Var}$} *)
-
-
-""" TRACE :
-Moyenne = 15.92301989946788
-Ecart type = 1.9934234202474366
-"""
-
-# 5.4 Variante : Exercice (suite écart type)
-
-echantillon=[random.gauss(16,2) for n in range(100)]
-varia = moyenne([x**2 for x in echantillon])-moyenne(echantillon)**2
-print("De la seconde façon : ", varia**0.5)
-
-""" Trace :
-De la seconde façon : 1.8839867058987951
-"""
diff --git a/TD01/code/06-script.py b/TD01/code/06-script.py
deleted file mode 100644
index 8af4da9adb789110606cc99ccd1cf58820da1274..0000000000000000000000000000000000000000
--- a/TD01/code/06-script.py
+++ /dev/null
@@ -1,16 +0,0 @@
-# 6 Créer un script Python indépendant
-
-from racines import trinome;
-print(trinome(2.0, -4.0, 2.0))
-
-
-# --- Partie Principale ---------
-print(trinome(1.0, -3.0, 2.0))
-print(trinome(1.0, -2.0, 1.0))
-print(trinome(1.0, 1.0, 1.0))
-
-""" On obtient
-(2, 1.0, 2.0)
-(1, 1.0)
-(0,) """
-
diff --git a/TD01/code/09-modules.py b/TD01/code/09-modules.py
deleted file mode 100644
index c692833f46826a0cf7bca5972c554f84f68ce828..0000000000000000000000000000000000000000
--- a/TD01/code/09-modules.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# Modules Python
-
-# import tel_module as mod1
-# import un_module as mod2
-# mod1.fonc(..) #appel de la fonction fonc du tel_module
-# mod2.fonc(..) #appel de la fonction homonyme du un_module
-
-# import tel_module
-#
-# def ma_fonction():
-# localname = tel_module.fonc
-# foo = localname(bar)
-
-import scipy.stats as st
-st.nanmean()
-
-# Si vous obtenez le message
-# ModuleNotFoundError: No module named 'scipy'
-# ..vous devez installer le module avec la commande
-#
-# pip3 install scipy
-#
\ No newline at end of file
diff --git a/TD01/code/10-range.py b/TD01/code/10-range.py
deleted file mode 100644
index c692833f46826a0cf7bca5972c554f84f68ce828..0000000000000000000000000000000000000000
--- a/TD01/code/10-range.py
+++ /dev/null
@@ -1,22 +0,0 @@
-# Modules Python
-
-# import tel_module as mod1
-# import un_module as mod2
-# mod1.fonc(..) #appel de la fonction fonc du tel_module
-# mod2.fonc(..) #appel de la fonction homonyme du un_module
-
-# import tel_module
-#
-# def ma_fonction():
-# localname = tel_module.fonc
-# foo = localname(bar)
-
-import scipy.stats as st
-st.nanmean()
-
-# Si vous obtenez le message
-# ModuleNotFoundError: No module named 'scipy'
-# ..vous devez installer le module avec la commande
-#
-# pip3 install scipy
-#
\ No newline at end of file
diff --git a/TD01/code/addition.py b/TD01/code/addition.py
index b2fcfda079ea637f4cbbb5b5bcfde6ae22ec657c..7bcc0fdaa90ddefdf70be2e2c7fce31175b7e9f8 100644
--- a/TD01/code/addition.py
+++ b/TD01/code/addition.py
@@ -1,2 +1,17 @@
def addition(a, b):
- return a + b
\ No newline at end of file
+ return a + b
+
+def addition_inf(*argv):
+ res = 0
+ for arg in argv:
+ res += arg
+ return res
+
+if __name__=="__main__":
+ assert addition(1, 2) == 3
+ assert not addition(1, 2) == 2
+
+ assert addition_inf(1, 1, 1) == 3
+ assert not addition_inf(1, 1, 1) == 2
+
+ assert addition_inf(1, 1, 1) == addition(1, 2)
\ No newline at end of file
diff --git a/TD01/code/chaines-valide.py b/TD01/code/chaines-valide.py
new file mode 100644
index 0000000000000000000000000000000000000000..0147ad7df28f5bccadf107f26f18380cadb77e99
--- /dev/null
+++ b/TD01/code/chaines-valide.py
@@ -0,0 +1,10 @@
+def valide(seq):
+ """Retourne True si séquence ADN."""
+ ret = len(seq) != 0
+ for c in seq:
+ ret = (ret and True) if (c in "atgc") else False
+ return ret
+
+if __name__=="__main__":
+ assert valide("atgc")
+ assert not valide("atgcz")
diff --git a/TD01/code/file.py b/TD01/code/file.py
new file mode 100644
index 0000000000000000000000000000000000000000..0b4906c58d0508de693f111c88c557ef604112a5
--- /dev/null
+++ b/TD01/code/file.py
@@ -0,0 +1,31 @@
+class File():
+ def __init__(self, values = []):
+ self.__values = []
+ for v in values:
+ self.ajoute(v)
+
+ def ajoute(self, v):
+ self.__values.append(v)
+ return v
+
+ def supprime(self):
+ v = self.__values.pop(0)
+ return v
+
+ def renvoie(self, critere = lambda x : True):
+ for v in self.__values:
+ if critere(v):
+ return v
+ return False
+
+ def affiche(self):
+ for v in self.__values:
+ print(v)
+
+ def taille(self):
+ return len(self.__values)
+
+if __name__ == "__main__":
+ f = File()
+ for d in [1, 2, 3]:
+ f.ajoute(d)
diff --git a/TD01/code/graphe_sim.py b/TD01/code/graphe-sim.py
similarity index 50%
rename from TD01/code/graphe_sim.py
rename to TD01/code/graphe-sim.py
index 43ee0648d1385eb03331001bb005e9e3ad7b3fb4..384c5b4fbbd928751058ec0557ab12382c55dbcd 100644
--- a/TD01/code/graphe_sim.py
+++ b/TD01/code/graphe-sim.py
@@ -18,6 +18,39 @@ graph = {'A': ['B', 'C'],
'F': ['C']
}
+class Graphe(dict):
+ def __init__(self, liens, noeuds):
+ for v in liens:
+ self[v] = set()
+ for e in noeuds:
+ self.ajout_noeud(e)
+
+ def ajout_lien(self, lien):
+ self[lien[0]].add(lien[1])
+ self[lien[1]].add(lien[0])
+
+ def ajout_noeud(self, noeud):
+ self[noeud] = set()
+
+def simGraphe(mots):
+ d = {}
+ g = Graphe(mots, [])
+
+ for mot in mots:
+ for i in range(len(mot)):
+ groupe = mot[:i] + '_' + mot[i+1:]
+ if groupe in d:
+ d[groupe].append(mot)
+ else:
+ d[groupe] = [mot]
+
+ for groupe in d.keys():
+ for mot1 in d[groupe]:
+ for mot2 in d[groupe]:
+ if mot1 != mot2:
+ g.ajout_lien([mot1, mot2])
+ return g
+
def chemin(graphe, source, destination, visite=None):
if source == destination:
diff --git a/TD01/code/lire_entier.py b/TD01/code/lire_entier.py
deleted file mode 100644
index 8c8a08e8ff4ce503402c15e11154cbecccb8de22..0000000000000000000000000000000000000000
--- a/TD01/code/lire_entier.py
+++ /dev/null
@@ -1,7 +0,0 @@
-# Exercice : pair/impair
-# Lire un entier au clavier et décider (et afficher) s'il est pair ou impair.
-a=int(input('Donner un entier positif : '))
-if (a%2 ==1):
- print(a, " est impair")
-else :
- print(a, " est pair")
diff --git a/TD01/code/liste_liee.py b/TD01/code/liste-liee.py
similarity index 100%
rename from TD01/code/liste_liee.py
rename to TD01/code/liste-liee.py
diff --git a/TD01/code/listes_lieee_test_boucle.py b/TD01/code/listes-liee-boucle.py
similarity index 100%
rename from TD01/code/listes_lieee_test_boucle.py
rename to TD01/code/listes-liee-boucle.py
diff --git a/TD01/code/moyenne.py b/TD01/code/moyenne.py
new file mode 100644
index 0000000000000000000000000000000000000000..cef6d9dc188cd88be2c2c6c38baeaa0601db0344
--- /dev/null
+++ b/TD01/code/moyenne.py
@@ -0,0 +1,10 @@
+# Calcul de la moyenne de deux entiers
+
+a=input('Donner la valeur de a : ')
+b=input('Donner la valeur de b : ')
+print('la moyenne = ', (int(a) + int(b))/2) # int(a) : conversion de 'a' en entier
+
+# Une seconde méthode : on convertit en lisant les valeurs en int
+a=int(input('Donner la valeur de a : '))
+b=int(input('Donner la valeur de b : '))
+print('la moyenne = ', (a+b)/2)
diff --git a/TD01/code/parite.py b/TD01/code/parite.py
new file mode 100644
index 0000000000000000000000000000000000000000..e9296579e7157dacaa3036a6cabbc0c2b043278c
--- /dev/null
+++ b/TD01/code/parite.py
@@ -0,0 +1,18 @@
+def parite(a):
+ """ Lire un entier au clavier et décider (et afficher) s'il est pair ou impair. """
+ if (a%2 == 1):
+ print(a, " est impair")
+ else :
+ print(a, " est pair")
+
+if __name__=="__main__":
+
+ while True:
+ try:
+ a = int(input('Donner un entier positif : '))
+ parite(a)
+ break
+ except ValueError:
+ print("Ce n'est pas un nombre valide.. ré-essayer !")
+
+
\ No newline at end of file
diff --git a/TD01/code/pile.py b/TD01/code/pile.py
new file mode 100644
index 0000000000000000000000000000000000000000..f8d2c74c6816c2ee6e1a5af262baac8136ac1dd5
--- /dev/null
+++ b/TD01/code/pile.py
@@ -0,0 +1,25 @@
+class Pile():
+ def __init__(self, values = []):
+ self.__values = []
+ for v in values:
+ self.ajoute(v)
+
+ def ajoute(self, v):
+ self.__values.append(v)
+ return v
+
+ def supprime(self):
+ v = self.__values.pop()
+ return v
+
+ def affiche(self):
+ for v in self.__values:
+ print(v)
+
+ def taille(self):
+ return len(self.__values)
+
+if __name__ == "__main__":
+ p = Pile()
+ for d in [1, 2, 3]:
+ p.ajoute(d)
diff --git a/TD01/code/racines.py b/TD01/code/racines.py
index fb23af6c0d9ee9a8b621cc84afa76c24d55d3089..ef69e2072efa87d7c3a17b5d59b9af87b3e508d5 100644
--- a/TD01/code/racines.py
+++ b/TD01/code/racines.py
@@ -1,8 +1,7 @@
-# Résolution équation quadratique
-
from math import sqrt;
def trinome(a, b, c):
+ """ Résolution équation quadratique """
delta = b**2 - 4*a*c
if delta > 0.0:
assert(a != 0)
diff --git a/TD01/code/recherche-dico.py b/TD01/code/recherche-dico.py
new file mode 100644
index 0000000000000000000000000000000000000000..427a4bb84aa0a176de669abc9c0278e75481bfe9
--- /dev/null
+++ b/TD01/code/recherche-dico.py
@@ -0,0 +1,16 @@
+def recherche(element, liste):
+ a = 0
+ b = len(liste)-1
+
+ while a < b :
+ m = (a+b) //2
+ if liste[m] == element :
+ return m
+ elif liste[m] > element :
+ b = m-1
+ else :
+ a = m+1
+
+ return a
+
+print (recherche(3, [3, 1, 4, 2, 3]))
diff --git a/TD01/code/tas.py b/TD01/code/tas.py
new file mode 100644
index 0000000000000000000000000000000000000000..31f40d3a619983954961f490c5e3fce191b531c8
--- /dev/null
+++ b/TD01/code/tas.py
@@ -0,0 +1,62 @@
+class Tas():
+ def __init__(self):
+ self.__values = []
+
+ def push(self, value):
+ self.__values.append(value)
+
+ def peek(self, i): # pop sans suppression
+ return self.__values[i], i
+
+ def fg(self, i):
+ left_i = 2 * i + 1
+ if left_i > len(self.__values):
+ return None, left_i
+ else:
+ return self.__values[left_i], left_i
+
+ def fd(self, i):
+ droite_i = 2 * i + 2
+ if droite_i > len(self.__values):
+ return None, droite_i
+ else:
+ return self.__values[droite_i], droite_i
+
+ def parent(self, i):
+ return self.__values[(i - 1) // 2]
+
+ def afficher(self):
+ return ' '.join(str(v) for v in self.__values)
+
+ def inserer(self, value):
+ self.push(value)
+ i = len(self.__values) - 1
+ while (i + 1) // 2 > 0:
+ if self.__values[i] < self.parent(i):
+ tmp = self.__values[i // 2]
+ self.__values[i // 2] = self.__values[i]
+ self.__values[i] = tmp
+ i = i // 2
+
+ def supprimer(self, i):
+
+ v = self.__values.pop(i)
+ max_i = i
+ n = len(self.__values) - 1
+
+ while self.__values[i] > self.fg(i)[0] or self.__values[i] > self.fd(i)[0]:
+
+ max = self.__values[i]
+
+ if i < n and max > self.fg(i)[0]:
+ max_i = 2 * i + 1
+
+ if i < n and max > self.fd(i)[0]:
+ max_i = 2 * i + 2
+
+ if max_i != i:
+ self.__values[i], self.__values[max_i] = self.__values[max_i], self.__values[i]
+
+ i = max_i
+
+ return v
\ No newline at end of file
diff --git a/TD01/code/tirage-des.py b/TD01/code/tirage-des.py
new file mode 100644
index 0000000000000000000000000000000000000000..baaa98a3dde6ec130fc96b6c9be39cdc6aa134dd
--- /dev/null
+++ b/TD01/code/tirage-des.py
@@ -0,0 +1,26 @@
+from random import *
+
+effectifs=[0,0,0,0,0,0]
+# OU
+# effectif=[0]*6
+for n in range(10000):
+ dice=randint(1,6)
+ effectifs[dice-1]+=1
+
+print(effectifs)
+
+#--> [1642, 1710, 1683, 1661, 1678, 1626]
+# Donner l'intervalle de confiance associé à ce résultat à 95%
+
+#Même chose avec 2 dés
+from random import *
+
+effectifs=[0]*11
+for n in range(10000):
+ de1=randint(1,6)
+ de2=randint(1,6)
+ twodice=de1+de2
+ effectifs[twodice-2]+=1
+
+print(effectifs)
+# --> [299, 540, 832, 1159, 1401, 1665, 1401, 1103, 787, 541, 272]
\ No newline at end of file
diff --git a/TD01/code/tirage-gaussienne.py b/TD01/code/tirage-gaussienne.py
new file mode 100644
index 0000000000000000000000000000000000000000..d456a089596fd937593038ece3d7b147925421c1
--- /dev/null
+++ b/TD01/code/tirage-gaussienne.py
@@ -0,0 +1,24 @@
+from math import *
+from random import *
+
+def tirage_gauss_centre_reduit():
+ x=uniform(0,1)
+ y=sqrt(-2*log(uniform(0,1)))
+ y = y*cos(x*2*pi)
+ return y
+
+try :
+ n=int(input("combien de valeurs : "))
+ for i in range(n) :
+ print("Le tirage : ", tirage_gauss_centre_reduit())
+except ValueError as err :
+ print("Error: {0}".format(err))
+
+""" TRACE :
+combien de valeurs : 5
+Le tirage : 0.1675459650607427
+Le tirage : -0.8810297798592189
+Le tirage : 0.4764601603767129
+Le tirage : -1.8446292482050937
+Le tirage : -0.35483078367598453
+"""
\ No newline at end of file
diff --git a/TD01/code/tirage-random.py b/TD01/code/tirage-random.py
new file mode 100644
index 0000000000000000000000000000000000000000..a9fe23f763c2dbcfd2440f3ae5a22454fa3b7d01
--- /dev/null
+++ b/TD01/code/tirage-random.py
@@ -0,0 +1,19 @@
+# imports
+from random import seed, random
+
+# fonctions
+def listAleatoireFloat(n):
+ """Retourne une liste de <n> flottants aleatoires."""
+ return [random() for i in range(n)]
+
+# programme principal
+n = int(input("Entrez un entier [2 .. 100] : "))
+while not (2 <= n <= 100): # saisie filtree
+ n = int(input("Entrez un entier [2 .. 100], s.v.p. : "))
+
+seed() # initialise le generateur de nombres aleatoires
+t = listAleatoireFloat(n) # construction de la liste
+
+print("Liste :", t)
+print("Amplitude : {:.2f}".format(max(t) - min(t)))
+print("Moyenne : {:.2f}".format(sum(t)/n))
\ No newline at end of file
diff --git a/TD01/code/tirage-remise.py b/TD01/code/tirage-remise.py
new file mode 100644
index 0000000000000000000000000000000000000000..8f0163d8ad7459558f4aa9a4caa282d49347f13c
--- /dev/null
+++ b/TD01/code/tirage-remise.py
@@ -0,0 +1,26 @@
+from math import *
+from random import *
+
+# Simulation d'un tirage avec remise de k objets parmi n
+
+def tirage_uniforme_k_of_n_avec_remise(n,k):
+ if k > n :
+ raise ValueError("k (%d) doit être =< que n (%d) " % (k,n))
+ T=[x for x in range(1,n+1,1)] # On constitue une urne avec p objets
+
+ for i in range(k) : # Tirage de k numéros
+ d=randint(1,n)
+ # On permute le d-ème élément de l'urne et la derniere
+ temp=T[d-1]
+ T[d-1]=T[n-1]
+ T[n-1]=temp
+ n=n-1
+ return T[n:n+k+1]
+
+
+n=int(input("La valeur de n ? "))
+k=int(input("La valeur de k (parmi n) ? "))
+try :
+ print("Le tirage : ", tirage_uniforme_k_of_n_avec_remise(n,k))
+except ValueError as err :
+ print("Error: {0}".format(err))
\ No newline at end of file
diff --git a/TD01/code/tri-bulle.py b/TD01/code/tri-bulle.py
new file mode 100644
index 0000000000000000000000000000000000000000..2ca66e1e7313bf8f6829f56eb5fb7fc7c66b66e6
--- /dev/null
+++ b/TD01/code/tri-bulle.py
@@ -0,0 +1,12 @@
+def tri_bulle_iteratif(lst):
+ """ Tri par bulle """
+ taille = len(lst)
+ for i in range(taille-1) :
+ for j in range(i+1, taille) :
+ if lst[i] > lst[j] :
+ lst[i] , lst[j] = lst[j] , lst[i] # permutaion
+ return lst
+
+liste=[1,3,13,4,7,2,9,2,18]
+print(tri_bulle_iteratif(liste))
+# [1, 2, 2, 3, 4, 7, 9, 13, 18]
\ No newline at end of file
diff --git a/TD01/code/tri-fusion.py b/TD01/code/tri-fusion.py
new file mode 100644
index 0000000000000000000000000000000000000000..16664517dc4a66b01397415b7c95c53a7ac83320
--- /dev/null
+++ b/TD01/code/tri-fusion.py
@@ -0,0 +1,62 @@
+from random import seed, randint, shuffle
+
+def tri_split_merge(L) :
+ """ TRI SPLIT-MERGE avec 2 fonctions imbriquées """
+ def my_split(L) :
+ choix=True # on met dans L1, sinon dans L2
+ L1=[]; L2=[] ; N =len(L)
+ i=0
+ while i < N :
+ crt=L[i]
+ if choix : L1.append(crt)
+ else : L2.append(crt)
+ i +=1
+ # voyons si on a une séquence Descendante
+ while i < N and L[i] >= crt :
+ crt=L[i]
+ if choix : L1.append(crt)
+ else : L2.append(crt)
+ i +=1
+
+ choix = not choix
+
+ return(L1,L2)
+
+ #---------------------
+ def my_merge(L1,L2) :
+ N1=len(L1)
+ N2=len(L2)
+ L=[]; i,j=0,0
+ while(i < N1 and j < N2) :
+ if L1[i] <= L2[j] :
+ L.append(L1[i])
+ i+=1
+ else :
+ L.append(L2[j])
+ j+=1
+ L.extend(L1[i:]) # Ajouter le reste de L1 (s'il y en a) à L
+ L.extend(L2[j:]) # Ajouter le reste de L2 (s'il y en a) à L
+ return L
+
+ # Fonction tri_split_merge
+ while True :
+ (L1,L2) = my_split(L)
+ if (L2==[]) : break # Fini
+ L=my_merge(L1,L2)
+ return L
+
+# programme principal -----------------------------------------------
+seed() # initialise le generateur de nombres aleatoires
+N=10
+L = [randint(2, N*4) for i in range(N)] # construction de la liste
+print("Avant le tri, liste = {}".format(L))
+L=tri_split_merge(L)
+print("Après le tri, liste = {}".format(L))
+
+""" Deux Traces
+Avant le tri, liste = [9, 17, 12, 24, 36, 26, 35, 25, 5, 31]
+Après le tri, liste = [5, 9, 12, 17, 24, 25, 26, 31, 35, 36]
+
+Avant le tri, liste = [30, 14, 2, 11, 5, 15, 5, 21, 29, 31]
+Après le tri, liste = [2, 5, 5, 11, 14, 15, 21, 29, 30, 31]
+"""
\ No newline at end of file
diff --git a/TD01/code/tri-insertion.py b/TD01/code/tri-insertion.py
new file mode 100644
index 0000000000000000000000000000000000000000..0f8c880440bfc5750ddb2a36d8b1895d49a0fc4d
--- /dev/null
+++ b/TD01/code/tri-insertion.py
@@ -0,0 +1,34 @@
+from random import seed, randint
+
+
+def tri_insertion_iter(T) :
+ def inserer_a_sa_place_iter(ind) : # insere le Ieme dans T[0:i]
+ save = T[ind]
+ i=ind
+ while (i>0 and T[i-1] > save) :
+ T[i]=T[i-1]
+ i -= 1
+ T[i]=save
+
+ if len(T) < 2 : return
+ for i in range(1,len(T)) :
+ inserer_a_sa_place_iter(i) # insere le Ieme dans T[0:i]
+
+# ------- Prog Princ
+seed() # initialise le generateur de nombres aleatoires
+N=10
+T = [randint(2, 3*N) for i in range(N)] # construction de la liste
+print("Avant le tri, liste = {}".format(T))
+TT=[] # Avant d'utiliser TT, il faut la faire exister !
+TT[:]=T[:]
+tri_insertion_iter(T)
+TT.sort()
+if (T == TT) :
+ print("Après le tri, liste = {}".format(T))
+else :
+ print("ERREUR !!, T={}, TT={}".format(T,TT))
+
+""" TRACE :
+Avant le tri, liste = [14, 11, 24, 24, 27, 14, 30, 22, 22, 17]
+Après le tri, liste = [11, 14, 14, 17, 22, 22, 24, 24, 27, 30]
+"""
\ No newline at end of file
diff --git a/TD01/code/tri_rapide.py b/TD01/code/tri-rapide.py
similarity index 72%
rename from TD01/code/tri_rapide.py
rename to TD01/code/tri-rapide.py
index 48ed21ca20232b6c8366ee3fef704543db26b863..c3e7230dcc9f5da46ea466c941a810a2d2307c9b 100644
--- a/TD01/code/tri_rapide.py
+++ b/TD01/code/tri-rapide.py
@@ -6,10 +6,12 @@ def quicksort(t):
t1 = []
t2 = []
for x in t[1:]:
- if x<pivot:
+ print(x, pivot)
+ if x < pivot:
t1.append(x)
else:
t2.append(x)
return quicksort(t1) + [pivot] + quicksort(t2)
-quicksort([1,4, 5])
\ No newline at end of file
+if __name__=="__main__":
+ quicksort([1 ,4, 5])
\ No newline at end of file
diff --git a/TD01/code/tri_fusion.py b/TD01/code/tri_fusion.py
deleted file mode 100644
index e4bdb86721ad39651ee67f4c0aadafaa1c55e788..0000000000000000000000000000000000000000
--- a/TD01/code/tri_fusion.py
+++ /dev/null
@@ -1,31 +0,0 @@
-def mergeSort(arr):
- if len(arr) >1:
- mid = len(arr)//2 #Finding the mid of the array
- L = arr[:mid] # Dividing the array elements
- R = arr[mid:] # into 2 halves
-
- mergeSort(L) # Sorting the first half
- mergeSort(R) # Sorting the second half
-
- i = j = k = 0
-
- # Copy data to temp arrays L[] and R[]
- while i < len(L) and j < len(R):
- if L[i] < R[j]:
- arr[k] = L[i]
- i+=1
- else:
- arr[k] = R[j]
- j+=1
- k+=1
-
- # Checking if any element was left
- while i < len(L):
- arr[k] = L[i]
- i+=1
- k+=1
-
- while j < len(R):
- arr[k] = R[j]
- j+=1
- k+=1
\ No newline at end of file
diff --git a/TD01/code/util-commentaires.py b/TD01/code/util-commentaires.py
new file mode 100644
index 0000000000000000000000000000000000000000..0c574e7bea0939dbf4c532a1059a0ee4538fe53a
--- /dev/null
+++ b/TD01/code/util-commentaires.py
@@ -0,0 +1,15 @@
+# Un commentaire court commence par un # et se limite à la fin de la ligne
+
+"""
+On peut aussi créer un commentaire long = une zone de
+commentaires sur plusieurs lignes placées
+entre une paire de triple-guillements dont le second suit :
+"""
+
+# Remarques :
+# Un ';' à la fin d'une ligne rend la ligne muette (pas d'affichage des résultats).
+# Il permet également de placer plusieurs expressions sur la même ligne.
+
+# Si vous placez un commentaire immédiatement après la signature d'une fonction}
+# (ou une méthode, une classe, etc.) entre un couple de """,
+# votre commentaire (appelé docstring) devient accessible avec help
\ No newline at end of file
diff --git a/TD01/code/08-conversion.py b/TD01/code/util-types-conversion.py
similarity index 100%
rename from TD01/code/08-conversion.py
rename to TD01/code/util-types-conversion.py
diff --git a/TD01/code/07-types.py b/TD01/code/util-types.py
similarity index 100%
rename from TD01/code/07-types.py
rename to TD01/code/util-types.py
diff --git a/TD01/code/test_version_python.py b/TD01/code/util-version-python.py
similarity index 100%
rename from TD01/code/test_version_python.py
rename to TD01/code/util-version-python.py
diff --git a/TD01/code/zip-codes-romain.py b/TD01/code/zip-codes-romain.py
new file mode 100644
index 0000000000000000000000000000000000000000..24f75cf9779dad80c57c874493215a941049dc02
--- /dev/null
+++ b/TD01/code/zip-codes-romain.py
@@ -0,0 +1,14 @@
+code = zip([1000,900 ,500,400 ,100,90 ,50 ,40 ,10 ,9 ,5 ,4 ,1], ["M" ,"CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"])
+
+# fonctions
+def zipConversionRomain(num):
+ res = []
+ for d, r in code:
+ while num >= d:
+ res.append(r)
+ num -= d
+ return ''.join(res)
+
+# programme principal -----------------------------------------------
+for i in range(1, 15):
+ print(i, zipConversionRomain(i))
\ No newline at end of file