TD01/code/moyenne.py

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

TD01/code/parite.py

-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

TD01/code/pile.py

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

TD01/code/premier.py

-from math import sqrt
-
-def premier(a):
-
-    # si == 1 ou ==2
-    if(a == 1 or a== 2):
-        return True
-    # si pair
-    elif(a % 2 == 0):
-        return False
-    else:
-        if (int(sqrt(a)) == sqrt(a)):
-            return False
-        
-        for k in range(3, int(sqrt(a)+1), 2):
-            if a % k == 0:
-               return False
-        
-        return True 
-    # autre
-
-assert premier(1) == True
-assert premier(2) == True
-assert premier(4) == False
-assert premier(9) == False
-
-assert premier(3) == True
-assert premier(20) == False
-assert premier(23) == True
-assert premier(6067) == True

TD01/code/racines.py

-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)      
-        racine_delta = sqrt(delta)
-        return (2, (-b-racine_delta)/(2*a), (-b+racine_delta)/(2*a))
-    elif delta < 0.0: return (0,)
-    else: 
-        assert(a != 0)     
-        return (1, (-b/(2*a)))
-    
-if __name__ == "__main__":
-    print(trinome(1.0, -3.0, 2.0))
-    print(trinome(1.0, -2.0, 1.0))
-    print(trinome(1.0, 1.0, 1.0))  
\ No newline at end of file

TD01/code/recherche-dichotomie-place.py

-def trouveOuDitOuInserer(sequence, val, inf=0, sup=None):
-    if sup is None:
-        sup = len(sequence)-1
-    if sup < inf :
-        return inf
-    mid = (inf + sup) // 2  
-    if sequence[mid] == val:  return mid
-    if sequence[mid] < val:   inf = mid + 1
-    else: sup = mid-1
-    return trouveOuDitOuInserer(sequence, val, inf, sup)
-3
-ary = (2, 3, 4,  6, 7,9,10, 12, 13)
-print('On cherche dans ', ary, ' et les places sont : ')
-print('7 ', trouveOuDitOuInserer(ary, 7, 0, len(ary) -1));input('?'); 
-print('2 ',trouveOuDitOuInserer(ary, 2, 0, len(ary) -1));input('?')
-print('5 ',trouveOuDitOuInserer(ary, 5, 0, len(ary) -1));input('?')
-print('15', trouveOuDitOuInserer(ary, 15, 0, len(ary) -1));input('?')
-print('1', trouveOuDitOuInserer(ary, 1, 0, len(ary) -1));input('?')
-
-""" tests
-On cherche dans  (2, 3, 4, 6, 7, 9, 10, 12, 13) et les places sont : 
-7  4
-2  0
-5  3
-15 9
-1  0
-"""
\ No newline at end of file

TD01/code/recherche-dichotomie.py

-from random import randint;
-
-def dichotomie(liste, val):
-    print("La liste reçue : ",liste, ' de taille ', len(liste))
-    if liste==[] : return False
-    m=len(liste)//2
-    print('\ton compare liste[',m,']=', liste[m], ' et ', val) 
-    if liste[m] == val: return True
-    elif liste[m] > val: return dichotomie(liste[:m], val)     # dans liste[:m], liste[m] n'est pas inclu.
-    else: return dichotomie(liste[m+1:], val)                  # dans liste[X:],  liste[X]  est  inclu.
- 
-ll=[randint(1,50) for i in range(10)]  
-ll.sort()
-x=int(input("chercher une valeur entre 1 et 50 dans la liste " + repr(ll) + " ? : "))
-print("La présence de  ", x, " dans la liste : ", ll, dichotomie(ll, x))    
-
-"""  
-# Et un cas de succès : 
-chercher une valeur entre 1 et 50 dans la liste [4, 7, 10, 14, 19, 27, 31, 32, 35, 47] ? : 32
-La liste reçue :  [4, 7, 10, 14, 19, 27, 31, 32, 35, 47]  de taille  10
-on compare liste[ 5 ]= 27  et  32
-La liste reçue :  [31, 32, 35, 47]  de taille  4
-on compare liste[ 2 ]= 35  et  32
-La liste reçue :  [31, 32]  de taille  2
-on compare liste[ 1 ]= 32  et  32
-La présence de   32  dans la liste :  [4, 7, 10, 14, 19, 27, 31, 32, 35, 47] True
-
-# Et un cas d'échec :
-chercher une valeur entre 1 et 50 dans la liste [22, 23, 30, 33, 37, 42, 42, 43, 47, 49] ? : 35
-La liste reçue :  [22, 23, 30, 33, 37, 42, 42, 43, 47, 49]  de taille  10
-on compare liste[ 5 ]= 42  et  35
-La liste reçue :  [22, 23, 30, 33, 37]  de taille  5
-on compare liste[ 2 ]= 30  et  35
-La liste reçue :  [33, 37]  de taille  2
-on compare liste[ 1 ]= 37  et  35
-La liste reçue :  [33]  de taille  1
-on compare liste[ 0 ]= 33  et  35
-La liste reçue :  []  de taille  0
-La présence de   35  dans la liste :  [22, 23, 30, 33, 37, 42, 42, 43, 47, 49] False
-"""
\ No newline at end of file

TD01/code/recherche-dico.py

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

TD01/code/rod-cutting.py

-INT_MIN = 0
-
-def cutRod(price, n): 
-
-    # Initialisation tables de cache
-    val = [0 for x in range(n+1)] 
-    val[0] = 0
-  
-    for i in range(1, n+1): 
-        max_val = INT_MIN 
-        for j in range(i): 
-             max_val = max(max_val, price[j] + val[i-j-1]) 
-        val[i] = max_val 
-  
-    return val[n] 
-  
-if __name__=="__main__": 
-    arr = [1, 5, 8, 9, 10, 17, 17, 20] 
-    size = len(arr) 
-    print("Valeur maximum de découpe " + str(cutRod(arr, size))) 
\ No newline at end of file

TD01/code/set-duplicatas.py

-def duplicatas(L):
-	s = set()
-	for x in L:
-		if x in s:
-			return True
-		s.add(x)
-	return False
-
-if __name__=="__main__": 
-	assert duplicatas([3, 5, 3]) == True
-	assert duplicatas([3, 5, 5]) == False

TD01/code/set-exemples.py

-{3,6,"cat",4.5,False}
-
-# {False, 4.5, 3, 6, 'cat'}     # L'ensemble est ordonné
-my_set = {3,6,"cat",4.5,False}
-my_set
-
-#{False, 3, 4.5, 6, 'cat'}
-
-len(my_set)
-# 5
-
-False in my_set
-# True
-
-"dog" in my_set
-#False
-
-your_set =  {99,3,100}
-my_set.union(your_set)
-# {False, 3, 4.5, 6, 99, 'cat', 100}
-
-my_set | your_set
-# {False, 3, 4.5, 6, 99, 'cat', 100}
-
-my_set.intersection(your_set)
-# {3}
-
-my_set & your_set
-# {3}
-
-my_set.difference(your_set)
-# {False, 4.5, 6, 'cat'}
-
-my_set - your_set
-# {False, 4.5, 6, 'cat'}
-
-{3,100}.issubset(your_set)
-# True
-
-{3,100} <= your_set
-# True
-
-my_set.add("house")
-my_set
-# {False, 3, 4.5, 6, 'house', 'cat'}
-
-my_set.remove(4.5)
-my_set
-# {False, 3, 6, 'house', 'cat'}
-
-my_set.pop()
-# False
-
-my_set
-# {3, 6, 'house', 'cat'}
-
-my_set.clear()
-my_set
-set()               # Ensemble vide
\ No newline at end of file

TD01/code/tas.py

-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

TD01/code/time.py

-import timeit
-
-print(timeit.timeit("x = 2 + 2"))
-#.0188..............
-
-print(timeit.timeit("x = range(10)"))
-#.589.........

TD01/code/tirage-des.py

-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

TD01/code/tirage-gaussienne.py

-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

TD01/code/tirage-random.py

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

TD01/code/tirage-remise.py

-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

TD01/code/tri-bulle.py

-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

TD01/code/tri-fusion.py

-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

TD01/code/tri-insertion.py

-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