TD01/code/graph-similarite.py

-# Par exemple pour Fool et Sage vous devez renvoyez le résultat suivant :
-# 
-# FOOL
-# POOL
-# POLL
-# POLE
-# PALE
-# SALE
-# SAGE
-# 
-# SOLUTION:
-
-graph = {'A': ['B', 'C'],
-  'B': ['C', 'D'],
-  'C': ['D'],
-  'D': ['C'],
-  'E': ['F'],
-  'F': ['C']
-}
-
-def chemin(graphe, source, destination, visite=None):
-
-    if source == destination:
-        return [destination]
-    else:
-        visite = visite or set()
-        for s in graphe[source]:
-                if s not in visite:
-                    visite.add(s)
-                    print("trace:", source + " > " + s)
-                    sous_chemin = chemin(graphe, s, destination, visite)
-                    if sous_chemin is not None:
-                        return [source] + sous_chemin
-
-print(chemin(simGraphe(["AA", "AB", "BC", "AC", "DD"]), "AA", "BC"))
-
-# ['AA', 'AB', 'AC', 'BC']
\ No newline at end of file

TD01/code/graphe-sim.py

-# Par exemple pour Fool et Sage vous devez renvoyez le résultat suivant :
-# 
-# FOOL
-# POOL
-# POLL
-# POLE
-# PALE
-# SALE
-# SAGE
-# 
-# SOLUTION:
-
-graph = {'A': ['B', 'C'],
-  'B': ['C', 'D'],
-  'C': ['D'],
-  'D': ['C'],
-  'E': ['F'],
-  '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:
-        return [destination]
-    else:
-        visite = visite or set()
-        for s in graphe[source]:
-                if s not in visite:
-                    visite.add(s)
-                    print("trace:", source + " > " + s)
-                    sous_chemin = chemin(graphe, s, destination, visite)
-                    if sous_chemin is not None:
-                        return [source] + sous_chemin
-
-print(chemin(simGraphe(["AA", "AB", "BC", "AC", "DD"]), "AA", "BC"))
-
-# ['AA', 'AB', 'AC', 'BC']
\ No newline at end of file

TD01/code/graphe_dico.py

-G = {
-    'A' : ['B','C', 'F'],
-    'B' : ['D', 'E'],
-    'C' : ['F'],
-    'D' : ['G'],
-    'E' : ['F'],
-    'F' : ['G', 'H'],
-    'G' : ['H'],
-    'H' : []
-}
-
-v = set()
-
-def traitement(v, G, n):
-    if n not in v:
-        v.add(n)
-        print(n)
-        for m in G[n]:
-            traitement(v, G, m)
-
-if __name__ == '__main__':
-    traitement(v, G, 'A')
-
-    if len(v) > 0:
-        print("Que se passe-t-il ?")

TD01/code/liste-liee.py

-class Node:
-    def __init__(self, data = None, next = None):
-        self.data = data
-        self.next = next
-
-class LinkedList:
-    def __init__(self):
-        self.head = None
-
-    def listprint(self):
-        printval = self.head
-        while printval is not None:
-            print(printval.dataval)
-            printval = printval.nextval
-    
-    def push(self, n):
-        if self.head is None:
-            self.head = Node(n)
-        else:
-            node = self.head
-            while node.next is not None:
-                node = node.next
-            node.next = Node(n)
-
-    def detectLoop(self):
-        s = set() 
-        temp = self.head 
-        while (temp):
-            if (temp in s): 
-                return True
-            s.add(temp) 
-            temp = temp.next
-        return False
\ No newline at end of file

TD01/code/listes-liee-boucle.py

-from liste_liee import *
-
-ll = liste_liee() # Ajout de données
-ll.push(20) 
-ll.push(4) 
-ll.push(15) 
-ll.push(10)
-   
-# Création d'une boucle
-ll.head.next.next.next.next = ll.head; 
-  
-if( ll.detectLoop()): 
-    print ("Il y a une boucle !") 
-else : 
-    print ("Pas de boucle ! ") 
\ No newline at end of file

TD01/code/listes-liees-boucle.py

-from LinkedList import *
-
-ll = LinkedList() # Ajout de données
-ll.push(20) 
-ll.push(4) 
-ll.push(15) 
-ll.push(10)
-   
-# Création d'une boucle
-ll.head.next.next.next.next = ll.head; 
-  
-if( ll.detectLoop()): 
-    print ("Il y a une boucle !") 
-else : 
-    print ("Pas de boucle ! ") 
\ No newline at end of file

TD01/code/math-addition.py

-def addition(a, b):
-    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

TD01/code/math-division.py

-def division(x, y):
-    return x / y
-
-if __name__=="__main__": 
-    try:
-        r = division(2, 1)
-        # division(2, 0)
-        # division("2", "1")
-    except ZeroDivisionError:
-        print("Division par zero !")
-    else:
-        print("Le résultat est", r)
-    finally:
-        print("Clause finale")
-

TD01/code/math-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/math-multiplication-rec.py

-def mult(a, b):
-  if(b == 1):
-    return a
-  else:
-    return a + mult(a, b-1)
-
-
-print(10 * 13, mult(10, 13))

TD01/code/math-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/math-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/math-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/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/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/recherche2.py

-def recherche(L, v):
-
-    if(len(L) <= 0):
-        return False
-
-    a = 0
-    b = len(L)
-    m = b // 2
-
-    if(L[m] == v):
-        return True
-    elif(L[m] > v):
-        return recherche(L[0:m], v)
-    elif(L[m] < v):
-        return recherche(L[m+1:b], v)
-    else:
-        return False
-
-if __name__=="__main__":
-    assert recherche([1, 2, 3], 1)
-    assert recherche([], 1) == False
-    assert recherche([1], 1) == True
-    assert recherche([1, 2, 3], 3) == True
\ No newline at end of file

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