Formattage code exemples

TD01/code/arbre_k_aire.py

+class Noeud:
+    def __init__(self, v, c = []):
+        self.v = v
+        self.c = c
+
+def parcours_affiche(arbre):
+    for c in arbre.c:
+        parcours_affiche(c)
+
+    print(arbre.v)
+
+
+def parcours_recherche(arbre, valeur):
+    stack = arbre.c
+
+    if valeur > arbre.v:
+        return False
+
+    if valeur == arbre.v:
+        return True
+
+    prev = stack[0].v
+
+    while len(stack) > 0:
+
+        children = stack.pop(0)
+
+        if valeur == children.v:
+            return True
+
+        if valeur > prev and valeur < children.v:
+            stack = children.c
+            prev = stack[0].v
+        else:
+            prev = children.v
+
+    return False
+
+
+racine = Noeud(13, [Noeud(4, [Noeud(1), Noeud(2), Noeud(3)]), Noeud(8, [Noeud(5), Noeud(6), Noeud(7)]),  Noeud(12, [Noeud(9), Noeud(10), Noeud(11)])])
+
+print(parcours_affiche(racine))
+print(parcours_recherche(racine, 11))
\ No newline at end of file

TD01/code/bfs-tree.py

+import collections
+class graph:
+    def __init__(self,gdict=None):
+        if gdict is None:
+            gdict = {}
+        self.gdict = gdict
+
+def bfs(graph, startnode):
+    seen, queue = set([startnode]), collections.deque([startnode])
+    while queue:
+        vertex = queue.popleft()
+        marked(vertex)
+        for node in graph[vertex]:
+            if node not in seen:
+                seen.add(node)
+                queue.append(node)
+
+def marked(n):
+    print(n)
+
+tree = { "a" : set(["b","c"]),
+                "b" : set(["e", "d"]),
+                "c" : set(["f"]),
+                "f" : set(["i"]),
+                "e" : set(["g", "h"]),
+                "d" : set(), "i" : set(), "g" : set(), "h" : set() 
+                }
+
+bfs(tree, "a")
\ No newline at end of file

TD01/code/bfs.py

+import collections
+class graph:
+    def __init__(self,gdict=None):
+        if gdict is None:
+            gdict = {}
+        self.gdict = gdict
+
+def bfs(graph, startnode):
+# Track the visited and unvisited nodes using queue
+        seen, queue = set([startnode]), collections.deque([startnode])
+        while queue:
+            vertex = queue.popleft()
+            marked(vertex)
+            for node in graph[vertex]:
+                if node not in seen:
+                    seen.add(node)
+                    queue.append(node)
+
+def marked(n):
+    print(n)
+
+if __name__=="__main__": 
+
+    gdict = { "a" : set(["b","c"]),
+                    "b" : set(["a", "d"]),
+                    "c" : set(["a", "d"]),
+                    "d" : set(["e"]),
+                    "e" : set(["a"])
+                    }
+
+    bfs(gdict, "a")
\ No newline at end of file

TD01/code/dfs-arbre.py

+def dfs(graph, start):
+    visited, stack = set(), [start]
+    while stack:
+        vertex = stack.pop()
+        if vertex not in visited:
+            visited.add(vertex)
+            stack.extend(graph[vertex] - visited)
+    return visited
+
+graph = {'A': set(['B', 'C']),
+         'B': set(['A', 'D', 'E']),
+         'C': set(['A', 'F']),
+         'D': set(['B']),
+         'E': set(['B', 'F']),
+         'F': set(['C', 'E'])}
+
+dfs(graph, 'A') # {'E', 'D', 'F', 'A', 'C', 'B'}
\ No newline at end of file

TD01/code/graph-cycle.py

+graph = { 0 : [1], 1 : [2], 2 : [3], 3 : [4], 4 : [1] }
+# https://algocoding.wordpress.com/2015/04/02/detecting-cycles-in-a-directed-graph-with-dfs-python/
+def cycle_existe(G):                    
+    color = { u : "white" for u in G  }  # Noeuds tous blancs
+    trouve_cycle = [False]                 
+ 
+    for u in G:                          # On visite tous les noeuds
+        if color[u] == "white":
+            dfs_visite(G, u, color, trouve_cycle)
+        if trouve_cycle[0]:
+            break
+    return trouve_cycle[0]
+ 
+def dfs_visite(G, u, color, trouve_cycle):
+    if trouve_cycle[0]:                         
+        return
+    color[u] = "gray"                  
+    for v in G[u]:                             
+        if color[v] == "gray":                 
+            trouve_cycle[0] = True       
+            return
+        if color[v] == "white":                
+            dfs_visite(G, v, color, trouve_cycle)
+    color[u] = "black"   
+
+print(cycle_existe(graph))
\ No newline at end of file

TD01/code/graph-get.py

+graph = { "a" : ["c"],
+          "b" : ["c", "e"],
+          "c" : ["a", "b", "d", "e"],
+          "d" : ["c"],
+          "e" : ["c", "b"],
+          "f" : []
+}
+
+
+def genere_arretes(graph):
+    edges = []
+    for node in graph:
+        for neighbour in graph[node]:
+            edges.append((node, neighbour))
+
+    return edges
+
+# Affiche les sommets
+print(list(graph.keys()))
+
+# Affiche les arrêtes
+print(genere_aretes(graph))
+
+# >>> [('a', 'c'), ('c', 'a'), ('c', 'b'), ('c', 'd'), ('c', 'e'), 
+#    ('b', 'c'), ('b', 'e'), ('e', 'c'), ('e', 'b'), ('d', 'c')]
\ No newline at end of file

TD01/code/graph-parcours-bellman.py

+def BellmanFord(self, src): 
+
+    # Distances infinies
+    dist = [float("Inf")] * self.V 
+    dist[src] = 0 
+
+    # Relache les sommets - 1
+    for i in range(self.V - 1): 
+ 
+        # Met a jour noeud et parents
+         for u, v, w in self.graph: 
+            if dist[u] != float("Inf") and dist[u] + w < dist[v]: 
+                    dist[v] = dist[u] + w 
+
+    # Verifie si cycle
+    for u, v, w in self.graph: 
+            if dist[u] != float("Inf") and dist[u] + w < dist[v]: 
+                    print "Le graphe contient des cycles négatifs"
+                    return
+    
\ No newline at end of file

TD01/code/graph-parcours-dijkstra.py

+class Graph:
+  def __init__(self):
+    self.nodes = set()
+    self.edges = defaultdict(list)
+    self.distances = {}
+
+  def add_node(self, value):
+    self.nodes.add(value)
+
+  def add_edge(self, from_node, to_node, distance):
+    self.edges[from_node].append(to_node)
+    self.edges[to_node].append(from_node)
+    self.distances[(from_node, to_node)] = distance
+
+
+def dijsktra(graph, initial):
+  visited = {initial: 0}
+  path = {}
+
+  nodes = set(graph.nodes)
+
+  while nodes: 
+    min_node = None
+    for node in nodes:
+      if node in visited:
+        if min_node is None:
+          min_node = node
+        elif visited[node] < visited[min_node]:
+          min_node = node
+
+    if min_node is None:
+      break
+
+    nodes.remove(min_node)
+    current_weight = visited[min_node]
+
+    for edge in graph.edges[min_node]:
+      weight = current_weight + graph.distance[(min_node, edge)]
+      if edge not in visited or weight < visited[edge]:
+        visited[edge] = weight
+        path[edge] = min_node
+
+  return visited, path
\ No newline at end of file

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/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/listes.py

-
-
-L = []
-
-L.ap    
\ No newline at end of file

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/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/tri-analyse.py

+# Comparaison des différents tris
+import time
+import random
+import matplotlib.pyplot as plt
+import numpy as np
+
+# On commence par définir une petite méthode "utilitaire" qui va nous servir souvent.
+# permute permet de permuter deux éléments situés aux indices i et j d'un tableau.
+def permute(tab, i, j):
+    '''
+    :e/s: tab, un tableau d'éléments
+    :entrees i et j: (int) les indices des éléments à permuter
+    :pre-cond: i et j sont des indices valides dans tab
+    :post-cond: le tableau est modifié, deux valeurs sont perumtées
+    '''
+    temp = tab[i]
+    tab[i] = tab[j]
+    tab[j] = temp
+
+# Tri par sélection
+# Rappel : on recherche le minimum du tableau, et on le permute avec l'élément dans la première case.
+#          Ensuite, on recherche le minimum dans le reste du tableau, et on le permute avec l'élément dans la 2ème case.
+#          Et ainsi de suite...
+
+
+def triSelection(tab):
+    '''
+    :e/s tab: tableau (de float)
+    :post-cond:
+       - ∀ i ∈ [0;len(tab)[, ∃ j ∈ [0;len(tab)[,  tabₛ[j] = tabₑ[i]
+         (les éléments de tab ont simplent changé d'ordre)
+       - ∀ i ∈ [1;len(tab)[,  tabₛ[i] ≥ tabₛ[i-1]
+         (les éléments de tab sont triés par valeur croissante)
+    :complexité : 𝓞(n²)
+    '''
+    for i in range(len(tab)-1):
+        indice_min = i
+        
+        # Boucle de recherche du minimum dans le tableau restant
+        for j in range(i+1,len(tab)):
+            if tab[j]<tab[indice_min]: 
+                indice_min=j
+        
+        # Une fois le min trouvé, on le permute pour le mettre à sa place
+        permute(tab, i, indice_min)
+        
+
+# Tri par insertion 
+# Rappel : on considère que le "début" du tableau est trié. 
+#          On se place au niveau de la première valeur non triée, et on la décale à gauche jusqu'à ce qu'elle trouve sa place
+#          Observez que la partie gauche du tableau est déjà triée... 
+
+
+# On commence par écrire une petite fonction utilitaire (une autre).
+# Cette fonction prend un élément à un indice i, et le décale sur 
+#   sa gauche jusqu'à ce qu'il soit à sa place... en faisant 
+#   l'hypothèse que tous les éléments sur sa gauche sont bien triés.
+
+def insereElt(tab, i):
+    '''
+    :e/s tab: tableau d'éléments
+    :entrée i: int
+    :pré-cond:
+       - 1 ≤ i < len(tab)
+       - ∀ j ∈ [1;i[,  tab[j] ≥ tab[j-1]  (tab est trié entre 0 et i-1)
+    :post-cond:
+       - ∀ j ∈ [0;i+1[, ∃ k ∈ [0;i+1[,  tabₛ[k] = tabₑ[j]
+         (les éléments entre 0 et i+1 ont simplement changé d'ordre)
+       - ∀ j ∈ [i+1;len(tab)[,  tabₛ[j] = tabₑ[j]
+         (les éléments au delà de i n'ont pas été modifiés)
+       - ∀ j ∈ [1;i+1[,  tab[j] ≥ tab[j-1]
+         (tab est trié entre 0 et i)
+    '''
+    while (tab[i-1] > tab[i]) and i>0 :
+        permute(tab, i, i-1)
+        i -= 1   
+
+# On écrit ensuite l'algo principal qui consiste à prendre
+#  tour à tour chaque élément "non trié", et à l'insérer dans
+#  le tableau trié (c'est-à-dire à le décaler jusqu'à sa bonne
+#  place sur sa gauche). 
+def triInsertion(tab):
+    '''
+    :e/s tab: tableau d'éléments
+    :pré- et post-conditions usuelles
+    '''
+    for i in range(1,len(tab)):
+        insereElt(tab, i)
+
+
+# Tri binaire, ou quicksort
+# Le quicksort est un tri récursif par excellence. 
+# Le principe est que l'on choisit une valeur pivot, 
+#   on range toutes les valeurs plus petites que le pivot à gauche du pivot
+#   et toutes les valeurs plus grandes à droite. 
+# Ensuite, on applique la même démarche sur les sous-tableaux gauche et droite. 
+# Une simulation intéressante est disponible ici : 
+# http://interactivepython.org/runestone/static/pythonds/SortSearch/TheQuickSort.html
+
+
+# On définit une méthode utilitaire qui va nous aider à partitionner notre tableau autour d'un pivot
+def partitionne(tab, imin, imax):
+    '''
+    :e/s tab: tableau d'éléments 
+    :entrée imin: int
+    :entrée imax: int
+    :sortie idroite: int
+    :pré-cond: 0 ≤ imin ≤ imax < len(tab)
+    :post-cond:
+       - imin ≤ idroite ≤ imax
+       - ∀ i ∈ [0;imin[ U ]imax;len(tab)[, tabₛ[i] = tabₑ[i]
+         (tab n'est pas modifié en dehors de la plage [imin;imax])
+       - ∀ i ∈ [imin;imax], ∃ j ∈ [imin;imax],  tabₛ[j] = tabₑ[i]
+         (les éléments de tab ont simplent changé d'ordre entre imin et imax)
+       - ∀ i ∈ [imin;idroite], tabₛ[i] ≤ tabₛ[idroite]
+         (les éléments à gauche du pivot lui sont inférieurs ou égaux)
+       - ∀ i ∈ ]idroite;imax], tabₛ[i] > tabₛ[idroite]
+         (les éléments à droite du pivot lui sont supérieurs)
+    '''
+    pivot = tab[imin] # On choisit arbitrairement le premier élément comme pivot 
+
+    igauche = imin + 1
+    idroite = imax
+    fini = False
+    while not fini:
+        while igauche <= idroite and tab[igauche] <= pivot:
+            igauche = igauche + 1
+        while tab[idroite] >= pivot and idroite >= igauche:
+            idroite = idroite - 1
+        if idroite < igauche:
+            fini= True
+        else:
+            temp = tab[igauche]
+            tab[igauche] = tab[idroite]
+            tab[idroite] = temp
+            #permute(tab, igauche, idroite)
+    temp = tab[imin]
+    tab[imin] = tab[idroite]
+    tab[idroite] = temp
+    #permute(tab, imin, imax)
+    return idroite
+
+
+# Si notre tableau n'est pas vide, on appelle tri_rec :
+# Sinon, le tableau vide n'est pas modifié. 
+def triRecursif(tab):
+    if len(tab) > 0:
+        tri_rec(tab, 0, len(tab)-1)
+
+def tri_rec(tab, imin, imax):
+    '''
+    :e/s tab: tableau d'éléments
+    :entrée imin: int
+    :entrée imax: int
+    :pré-cond: 0 ≤ imin ≤ imax < len(tab) (les indices existent dans le tableau)
+    :post-cond:
+       - ∀ i ∈ [0;imin[ U ]imax;len(tab)[, tabₛ[i] = tabₑ[i]
+         (tab n'est pas modifié en dehors de la plage [imin;imax])
+       - ∀ i ∈ [imin;imax], ∃ j ∈ [imin;imax],  tabₛ[j] = tabₑ[i]
+         (les éléments de tab ont simplent changé d'ordre entre imin et imax)
+       - ∀ i ∈ [imin;imax[,  tabₛ[i+1] ≥ tabₛ[i]
+         (tab est trié entre imin et imax)
+    '''
+    if imin < imax:
+        # partition the list
+        pivot = partitionne(tab, imin, imax)
+        # sort both halves
+        tri_rec(tab, imin, pivot-1)
+        tri_rec(tab, pivot+1, imax)
+    return tab
+
+# Tri bulle 
+def triBulle(tab):
+    '''
+    :entree/sortie: tab un tableau d'éléments
+    :post-condition : tab est trié
+    ''' 
+    swap = True
+    while swap == True:
+        swap = False
+        for j in range(0,len(tab)-1):
+            if tab[j]>tab[j+1]:
+                swap = True
+                temp=tab[j]
+                tab[j]=tab[j+1]
+                tab[j+1]=temp
+
+
+
+
+nvalues = [10, 100, 500, 1000]
+timesSelection = []
+timesInsertion = []
+timesBulle = []
+timesRecursif = []
+
+for i in nvalues:
+    random.seed()
+    p = 12**2 # Ordre de grandeur des valeurs
+    liste = []
+    
+    for x in range(i): liste.append(random.randint(0, p))
+
+    tableau = list(liste)
+    a=time.process_time()
+    triSelection(tableau)
+    if x <= 10:
+        print(tableau)
+    b=time.process_time()
+    timesSelection.append(b-a)
+
+    tableau = list(liste)
+    a=time.process_time()
+    triInsertion(tableau)
+    if x <= 10:
+        print(tableau)
+    b=time.process_time()
+    timesInsertion.append(b-a)
+
+    tableau = list(liste)
+    a=time.process_time()
+    triRecursif(tableau)
+    if x <= 10:
+        print(tableau)
+    b=time.process_time()
+    timesRecursif.append(b-a)
+    
+    tableau = list(liste)
+    a=time.process_time()
+    triBulle(tableau)
+    if x <= 10:
+        print(tableau)
+    b=time.process_time()
+    timesBulle.append(b-a)
+
+print(nvalues)
+
+print(timesSelection)
+print(timesInsertion)
+print(timesRecursif)
+print(timesBulle)
+
+
+#xs = range(0,1000)
+plt.plot(nvalues,timesSelection, "r-", label="Tri par sélection")
+plt.plot(nvalues,timesInsertion, "g-", label="Tri par insertion")
+plt.plot(nvalues,timesRecursif, "b-", label="Tri par récursif")
+plt.plot(nvalues,timesBulle, "g--", label="Tri bulles")
+
+#plt.plot(nvalues,timesRecursif, "b-", label="Quick sort")
+#plt.plot(xs, sqrt(xs), "r-", label=" √n")
+plt.title("Comparaison des performances des différents algorithmes de tri")
+
+
+
+plt.savefig('analyse-tri.png')
+
+# Outil pour tester les algos de tri à la main 
+tableauATrier = [42,1,6,0,8,9,2,4,7,3,19,34,23,67,45,23,105,18,190,20]
+triBulle(tableauATrier)
+print(tableauATrier)