Merge branch 'master' of codefirst.iut.uca.fr:antoine.perederii/IUT

1A/BDD/tp/BDDs2/tp1/requetes_tp14.sql

@@ -0,0 +1,19 @@
+-- 1 Ecrire une requête permettant de lister les codes de pays et le nombre de médailles d’or qu’ils ont remporté.
+-- Attention, il ne faut pas compter plusieurs médailles remportées lors d’épreuves par équipes, autrement
+-- dit lorsque plusieurs athlètes d’un même pays remporte la même médaille lors d’une épreuve.
+
+SELECT pays, COUNT(*) AS nb_medailles_or
+FROM Medailles
+WHERE medaille = 'Or'
+GROUP BY pays
+ORDER BY nb_medailles_or DESC;
+
+
+-- 2  Transformer la requête précédente en vue nommée MedaillesOr
+
+CREATE VIEW MedaillesOr AS
+SELECT pays, COUNT(*) AS nb_medailles_or
+FROM Medailles
+WHERE medaille = 'Or'
+GROUP BY pays
+ORDER BY nb_medailles_or DESC;

1A/BDD/tp/BDDs2/tp1/tp14.sql

@@ -0,0 +1,137 @@
+-- 1. Écrire une requête permettant de lister les codes de pays et le nombre de médailles d’or qu’ils ont remporté
+SELECT a.pays code_pays,
+    COUNT(DISTINCT r.epreuve) medailles_or
+FROM resultat r
+INNER JOIN athlete a ON a.code = r.athlete
+WHERE r.medaille = (
+    SELECT place FROM medaille WHERE couleur = 'Or'
+)
+GROUP BY a.Pays
+ORDER BY medailles_or DESC;
+
+-- 2. Transformer la requête précédente en vue nommée MedaillesOr.
+CREATE VIEW MedaillesOr AS SELECT a.pays code_pays, COUNT(DISTINCT r.epreuve) medailles_or
+                            FROM resultat r, athlete a 
+                            WHERE a.code = r.athlete AND r.medaille = (
+                                                                        SELECT place 
+                                                                        FROM medaille 
+                                                                        WHERE couleur = 'Or')
+                            GROUP BY a.pays;
+
+-- 3. Utiliser la vue créée pour trouver le nombre de médailles d’or remportées par la France.
+SELECT medailles_or FROM MedaillesOr WHERE code_pays = 'FRA';
+
+-- 4. Comme pour MedaillesOr, créer deux vues MedaillesArgent et MedaillesBronze associant le code des pays au nombre de médailles d’argent et de bronze remportées, respectivement.
+
+CREATE VIEW MedaillesArgent AS SELECT a.pays code_pays, COUNT(DISTINCT r.epreuve) medailles_argent
+                            FROM resultat r, athlete a 
+                            WHERE a.code = r.athlete AND r.medaille = (
+                                                                        SELECT place 
+                                                                        FROM medaille 
+                                                                        WHERE couleur = 'Argent')
+                            GROUP BY a.pays;
+
+CREATE VIEW MedaillesBronze AS SELECT a.pays code_pays, COUNT(DISTINCT r.epreuve) medailles_bronze
+        FROM resultat r, athlete a 
+        WHERE a.code = r.athlete AND r.medaille = (
+                                                    SELECT place 
+                                                    FROM medaille 
+                                                    WHERE couleur = 'Bronze')
+        GROUP BY a.pays;        
+
+-- 5. Créer une vue TableauMedailles listant le nombre de médailles d’or, d’argent, de bronze et
+-- le total de médailles remportées par chaque pays. Les pays ayant remporté le plus de médailles d’or
+-- apparaitront en premier, puis ceux ayant remporté le plus de médailles d’argent et enfin ceux ayant
+-- remporté le plus de médailles de bronze.
+
+CREATE VIEW TableauMedailles AS
+    SELECT p.nom pays,
+        o.medailles_or, a.medailles_argent, b.medailles_bronze, 
+        (o.medailles_or + a.medailles_argent + b.medailles_bronze) total_medailles
+    FROM pays p, MedaillesOr o, MedaillesArgent a, MedaillesBronze b
+    WHERE o.code_pays = p.code AND a.code_pays = p.code AND b.code_pays = p.code AND 
+        medailles_or IS NOT NULL
+        OR medailles_argent IS NOT NULL
+        OR medailles_bronze IS NOT NULL 
+    ORDER by total_medailles DESC;-- Retire les pays qui ont 0 médaille peu importe la couleur
+
+SELECT * FROM TableauMedailles WHERE pays = 'France';
+
+-- 6. Afficher le tableau des médailles
+SELECT * FROM tableaumedailles;
+
+-- 7. Un organe de presse souhaite faire son propre classement, en ordonnant les pays en fonction
+-- du nombre total de médailles remportées, et par ordre alphabétique des noms de pays en cas d’égalité.
+-- Sans modifier votre vue TableauMedailles, afficher ce nouveau classement.
+
+SELECT * 
+FROM TableauMedailles 
+ORDER BY (total_medailles) DESC, (pays) ASC;
+
+
+--! Partie 2
+
+-- 1. Ecrire une requête SQL calculant le nombre d’athlètes pratiquants par discipline et par pays
+-- (trié par discipline, puis pays).
+
+SELECT pa.nom AS pays, d.code AS discipline, count(*) AS nb_athletes
+FROM Athlete a, Pays pa, Pratiquer pr, Discipline d
+WHERE a.pays = pa.code AND pr.athlete = a.code AND d.code = pr.discipl
+GROUP BY pa.nom, d.code;
+
+-- 2. Transformer la requête précédente en vue Pratiquants_v1.
+DROP VIEW Pratiquants_v1 cascade;
+CREATE VIEW Pratiquants_v1 AS SELECT pa.nom AS pays, d.code AS discipline, count(*) AS nb_athletes  
+                                FROM Athlete a, Pays pa, Pratiquer pr, Discipline d
+                                WHERE a.pays = pa.code AND pr.athlete = a.code AND d.code = pr.discipl
+                                GROUP BY pa.nom, d.code;
+
+-- 3. Même chose pour Pratiquants_v2 mais ce sera une vue matérialisée
+
+CREATE MATERIALIZED VIEW Pratiquants_v2 AS SELECT pa.nom AS pays, d.code AS discipline, count(*) AS nb_athletes  
+                                            FROM Athlete a, Pays pa, Pratiquer pr, Discipline d
+                                            WHERE a.pays = pa.code AND pr.athlete = a.code AND d.code = pr.discipl
+                                            GROUP BY pa.nom, d.code;
+
+-- 4. Utiliser les vues créées précédemment pour afficher le nombre d’athlètes français pratiquant le
+-- judo (code ’JUD’)
+
+SELECT * 
+FROM Pratiquants_v1
+WHERE pays = 'France' AND discipline = 'JUD';
+
+SELECT * 
+FROM Pratiquants_v2
+WHERE pays = 'France' AND discipline = 'JUD';
+
+-- 5.Teddy RINER ne pratique plus le judo mais le skateboard (code ’SKB’). Faire les modifications
+-- nécessaires.
+-- UPDATE discipl
+-- SET discipl = 'SKB'
+-- FROM Pratiquer
+-- WHERE athlete = (a.code FROM Athlete a WHERE a.nom = 'Riner');
+
+UPDATE pratiquer 
+SET discipl = 'SKB' 
+WHERE athlete = (
+                SELECT code 
+                FROM Athlete
+                WHERE nom = 'RINER');
+
+-- 6. Réafficher le nombre d’athlètes français pratiquant le judo (code ’JUD’).
+-- Comparer le résultat obtenu avec les 2 vues. Pourquoi cette différence ?
+
+SELECT * 
+FROM Pratiquants_v2
+WHERE pays = 'France' AND discipl = 'JUD';
+
+SELECT * 
+FROM Pratiquants_v1
+WHERE pays = 'France' AND discipl = 'JUD';
+
+-- car elle est pas update
+
+-- 7. Que faut-il faire pour que les deux vues affichent le même résultat ? Vérifier
+
+-- mettre 
+-- REFRESH MATERIALIZED VIEW Pratiquants_v2;

1A/Maths/tp/Graphs/3_tp/tp3.py

@@ -0,0 +1,103 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+""" H=nx.Graph() #cr ́ee un graphe
+H.add_edge(0,1) #ajoute une arˆete entre les sommets 0 et 1
+H.add_edges_from([(3,0),(3,4)]) #ajoute les arˆetes d’une liste donn ́ee
+H.add_node("toto") #ajoute un sommet nomm ́e "toto"
+H.remove_node(s) #supprime le sommet s
+H.nodes #sommets du graphe (attention, pour en faire une vraie liste Python,  ́ecrire: list(H.nodes))
+H.edges #arˆetes du graphe (attention, pour en faire une vraie liste Python,  ́ecrire: list(H.edges))
+H.edges(s) #les arˆetes qui touchent le sommet s
+H.neighbors(s) #un it ́erateur sur les voisins du sommet s dans H pour obtenir une liste,  ́ecrire: list(H.neighbors(s))
+H.nodes[s]["attri"] #acc`ede `a l’attribut nomm ́e "attri" du sommet s (tant en lecture qu’en  ́ecriture) exemple: H.nodes[s]["attri"]=2 ou alors print(H.nodes[s]["attri"])
+ """
+
+# les arbres
+
+def ajouter_file(F, v):
+    F.append(v)
+    return
+
+def enlever_tete_file(F):
+    return F.pop(0)
+
+def file_vide(F):
+    return len(F) == 0
+
+def valeur_tete_file(F):
+    return F[0]
+
+def ajouter_pile(P, v):
+    P.append(v)
+    return
+
+def enlever_tete_pile(P):
+    return P.pop()
+
+def pile_vide(P):
+    return len(P) == 0
+
+def valeur_tete_pile(P):
+    return P[-1]
+
+
+F=[]
+P=[]
+print(file_vide(F))
+print(file_vide(P))
+ajouter_file(F, 1)
+ajouter_file(F, 2)
+enlever_tete_file(F)
+print(F)
+ajouter_pile(P, 1)
+ajouter_pile(P, 2)
+enlever_tete_pile(P)
+print(P)
+valeur_tete_file(F)
+valeur_tete_pile(P)
+
+G=nx.Graph()
+G.add_edges_from([(1,2),(1,5),(2,3),(2,5),(3,4),(4,5),(4,6),(5,0)])
+nx.draw(G,with_labels=True)
+plt.show()
+
+
+def parcours_largeur(G, s):
+    V = [s]
+    F = [s]
+    while F:
+        x = F.pop(0)
+        for y in G.neighbors(x):
+            if y not in V:
+                V.append(y)
+                F.append(y)
+    return V
+
+
+print(parcours_largeur(G, 0))
+print(parcours_largeur(G, 1))
+print(parcours_largeur(G, 2))
+print(parcours_largeur(G, 3))
+print(parcours_largeur(G, 4))
+print(parcours_largeur(G, 5))
+
+
+# ecrire la fonction parcours profondeur(G,s) qui effectue un parcours en profondeur
+# du graphe G `a partir du sommet s, et qui retourne la liste des sommets visit ́es.
+
+
+
+def parcours_profondeur(G, s):
+    V = [s]
+    P = [s]
+    while P:
+        x = P.pop()
+        for y in G.neighbors(x):
+            if y not in V:
+                V.append(y)
+                P.append(y)
+    return V
+

1A/Maths/tp/Graphs/4_tp/tp3_Solut.py

@@ -0,0 +1,398 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+import numpy as np
+import random as rd
+
+# G=nx.Graph()
+# G.add_edges_from([(1,2),(1,5),(2,3),(2,5),(3,4),(4,5),(4,6),(5,0)])
+# nx.draw(G,with_labels=True)
+# plt.show()
+
+#############################
+G=nx.Graph()
+G.add_edges_from([(1,2),(1,5),(2,3),(2,5),(3,4),(4,5),(4,6),(5,0)])
+nx.draw(G,with_labels=True)
+plt.show()
+#############################
+H=nx.Graph()
+H.add_nodes_from([1,2,3,4,5,6,7,8,9,10,11])
+H.add_edges_from([(1,2),(1,5),(2,3),(2,5),(4,6),(5,0),(8,11),(9,8),(10,8)])
+nx.draw(H,with_labels=True)
+plt.show()
+#############################
+
+#######################
+ArbreBin=nx.Graph()
+ArbreBin.add_edges_from([(1,2),(1,5),(3,4),(4,5),(4,6),(5,0)])
+# dessin ́e comme ceci
+nx.draw(ArbreBin,with_labels=True)
+plt.show()
+# ou comme cela
+# dico_pos_arbre = {1:(0,0),2:(-1,-1),5:(2,-1),0:(1,-2),4:(3,-2),3:(2,-3), 6:(4,-3)}
+# nx.draw(ArbreBin,dico_pos_arbre,with_labels=True)
+plt.show()
+######################
+
+
+
+####################################
+## primitives des files
+####################################
+##enfiler
+def ajouter_file(F,v):
+    F.append(v)
+    return
+##d ́efiler
+def enlever_tete_file(F):
+    del F[0]
+    return;
+##regarder la valeur en tˆete de file
+def valeur_tete_file(F):
+    return F[0]
+##tester si la file est vide
+def est_file_vide(F):
+    return len(F)==0
+
+## petit test sur les files :
+def test_file():
+    F=[]
+    ajouter_file(F,5)
+    print(F)
+    ajouter_file(F,3)
+    print(F)
+    ajouter_file(F,8)
+    ajouter_file(F,2)
+    print(F)
+    enlever_tete_file(F)
+    print("on a enlev ́e la tete")
+    print(F)
+    if est_file_vide(F) : print("PB : la file est vide")
+    else : print("en tete de file : " + str(valeur_tete_file(F)))
+    enlever_tete_file(F)
+    enlever_tete_file(F)
+    enlever_tete_file(F)
+    if est_file_vide(F) : print("OK : la file est vide")
+    else : print("PB : la file n’est pas vide")
+    return
+####################################
+## primitives des piles
+####################################
+##empiler
+def ajouter_pile(P,v):
+    P.append(v)
+    return
+##d ́epiler
+def enlever_sommet_pile(P):
+    del P[len(P)-1] # ou alors P.pop()
+    return;
+##regarder
+def valeur_sommet_pile(P):
+    return P[len(P)-1]
+##tester
+def est_pile_vide(P):
+    return len(P)==0
+
+## petit test sur les piles :
+def test_pile():
+    P=[]
+    ajouter_pile(P,5)
+    ajouter_pile(P,3)
+    ajouter_pile(P,8)
+    ajouter_pile(P,2)
+    print(P)
+    enlever_sommet_pile(P)
+    print("on a enlev ́e le sommet")
+    print(P)
+    if est_pile_vide(P) : print("la pile est vide")
+    else : print("au sommet : " + str(valeur_sommet_pile(P)))
+    enlever_sommet_pile(P)
+    enlever_sommet_pile(P)
+    enlever_sommet_pile(P)
+    if est_pile_vide(P) : print("OK : la pile est vide")
+    else : print("PB : la pile n’est pas vide")
+    return
+
+
+########### parcours en largeur ##############
+def parcours_largeur(G,s):
+    visites = [] # sommets vus (compl`etement ou juste dans la fronti`ere)
+    F = [] # la fronti`ere
+    visites.append(s)
+    ajouter_file(F,s)
+    while(not est_file_vide(F)):
+        v = valeur_tete_file(F)
+        trouve = False # voisin de v non deja visite pas encore trouv ́e
+        for u in G.neighbors(v):
+            if (u not in visites) :
+                visites.append(u)
+                ajouter_file(F,u)
+                trouve = True # voisin de v non deja visite trouv ́e
+                break
+        if not trouve :
+            enlever_tete_file(F)
+    return visites
+
+print(parcours_largeur(G,1))
+
+
+# Une autre solution :
+def parcours_largeur(H,s):
+    visites=[]
+    F=[]
+    visites.append(s)
+    ajouter_file(F,s)
+    while not est_file_vide(F):
+        v = valeur_tete_file(F)
+        L = [t for t in H.neighbors(v) if t not in visites]
+        if len(L) != 0:
+            visites.append(L[0])
+            ajouter_file(F,L[0])
+        else:
+            enlever_tete_file(F)
+    return visites
+
+
+print(parcours_largeur(G,1))
+
+########### parcours en profondeur ##############
+def parcours_profondeur(G,s):
+    visites = []
+    P = [] # la fronti`ere
+    visites.append(s)
+    ajouter_pile(P,s)
+    while(not est_pile_vide(P)):
+        v = valeur_sommet_pile(P)
+        trouve = False # voisin de v non deja visite pas encore trouv ́e
+        for u in G.neighbors(v):
+            if (u not in visites) :
+                visites.append(u)
+                ajouter_pile(P,u)
+                trouve = True # voisin de v non deja visite trouv ́e
+                break
+        if not trouve :
+            enlever_sommet_pile(P)
+    return visites
+
+
+print(parcours_profondeur(G,1))
+
+
+# Une autre solution :
+
+def parcours_profondeur(H,s):
+    visites=[]
+    P=[]
+    visites.append(s)
+    ajouter_pile(P,s)
+    while not est_pile_vide(P):
+        v = valeur_sommet_pile(P)
+        L = [t for t in H.neighbors(v) if t not in visites]
+        6
+        if len(L) != 0:
+            visites.append(L[0])
+            ajouter_pile(P,L[0])
+        else:
+            enlever_sommet_pile(P)
+    return visites
+
+print(parcours_profondeur(G,1))
+
+
+# ! TP 4
+
+# ? Exercice 1
+
+
+
+# Ecrire une fonction est_connexe(G) qui determine si un graph G est connexe, en utlisant un des deux algorithmes de parcours vus en semaine 3 (voir solution sur moodle)
+
+def est_connexe(G):
+    return len(parcours_largeur(G,1)) == len(G.nodes())
+
+
+# Ecrire une fonction composantes connexes(G) qui calcule et retourne la liste des composantes connexes d'un graph G
+
+def composantes_connexes(G):
+    visites = []
+    composantes = []
+    for s in G.nodes():
+        if s not in visites:
+            composantes.append(parcours_largeur(G,s))
+            visites.extend(parcours_largeur(G,s))
+    return composantes
+
+# Tester les deux fonctions précédentes avec les graphes G et H
+print("=========================== Exo 1 ===========================")
+print(est_connexe(G))
+print(est_connexe(H))
+print(composantes_connexes(G))
+print(composantes_connexes(H))
+
+
+# ? Exercice 2
+
+# Ecrire une fonction distances(G,s) qui, pour un graphe G connexe et un sommet s donn ́es, calcule la distance (en nombre d’arˆetes) entre s et chaque sommet de G. Cette fonction retourne un dictionnaire associant une distance `a chaque sommet. Pour cela, comme vu en cours, on modifie le parcours en largeur.
+
+def distances(G,s):
+    visites = []
+    F = []
+    distances = {}
+    visites.append(s)
+    ajouter_file(F,s)
+    distances[s] = 0
+    while(not est_file_vide(F)):
+        v = valeur_tete_file(F)
+        trouve = False # voisin de v non deja visite pas encore trouv ́e
+        for u in G.neighbors(v):
+            if (u not in visites) :
+                visites.append(u)
+                ajouter_file(F,u)
+                distances[u] = distances[v] + 1
+                trouve = True # voisin de v non deja visite trouv ́e
+                break
+        if not trouve :
+            enlever_tete_file(F)
+    return distances
+
+print("=========================== Exo 2 ===========================")
+print(distances(G,1))
+print(distances(H,1))
+
+
+# (optionnel)  ́Ecrire une fonction affiche plus courts chemins a partir de(G,s) qui,
+# pour un graphe G connexe et un sommet s donn ́es, affiche pour chaque sommet du
+# graphe un plus court chemin `a partir de s.
+# Cette fonction appellera la fonction plus courts chemins(G,s) qui calcule pour chaque
+# sommet son pr ́ed ́ecesseur (le sommet par lequel il est d ́ecouvert lors du parcours `a par-
+# tir de s).
+# Exemple : affiche plus courts chemins a partir de(G,1) (avec G de l’exercice
+# pr ́ec ́edent) donnera :
+# 1
+# 2 <- 1
+# 5 <- 1
+# 3 <- 2 <- 1
+# 4 <- 5 <- 1
+# 6 <- 4 <- 5 <- 1
+# 0 <- 5 <- 1
+
+def affiche_plus_courts_chemins_a_partir_de(G,s):
+    distance = distances(G,s)
+    for i in range(len(G.nodes())):
+        chemin = str(i)
+        j = i
+        while j != s:
+            j = distance[j]
+            chemin = str(j) + " <- " + chemin
+        print(chemin)
+    
+affiche_plus_courts_chemins_a_partir_de(G,1)
+
+
+# ? Exercice 3
+
+# Un arbre binaire est un arbre qui poss`ede une unique racine (un sommet particulier) et
+# o`u chaque sommet a au plus deux sommets voisins sp ́eciaux, appel ́es ses fils. S’il a deux fils,
+# l’un est le fils gauche et l’autre est le fils droit. Un sommet est appel ́e le p`ere de son fils. Ainsi,
+# chaque sommet de l’arbre binaire a au maximum trois voisins (deux fils et un p`ere). La racine
+# n’a pas de p`ere, et les feuilles sont les sommets sans fils.
+# Dans cet exercice, on s’int ́eresse au parcours en profondeur d’un arbre binaire T `a partir de
+# sa racine r. Un certain traitement doit ˆetre effectu ́e une fois et une seule sur chaque sommet
+# au cours de ce parcours. Ici, le traitement consiste simplement `a afficher le nom du sommet.
+# Vous pourrez tester vos programmes sur l’arbre ArbreBin ci-dessous, dont la racine est le
+# sommet 1.
+# #######################
+# ArbreBin=nx.Graph()
+# ArbreBin.add_edges_from([(1,2),(1,5),(3,4),(4,5),(4,6),(5,0)])
+# # dessin ́e comme ceci
+# nx.draw(ArbreBin,with_labels=True)
+# plt.show()
+# # ou comme cela
+# dico_pos_arbre = {1:(0,0),2:(-1,-1),5:(2,-1),0:(1,-2),4:(3,-2),3:(2,-3), 6:(4,-3)}
+# nx.draw(ArbreBin,dico_pos_arbre,with_labels=True)
+# plt.show()
+# #######################
+
+
+# Ecrire une fonction qui affiche le nom de chaque sommet au moment o`u il est ajout ́e `a la pile. Ce type de parcours en profondeur d’un arbre binaire s’appelle un parcours pr ́efixe.
+
+
+def parcours_prefixe(T,r):
+    visites = []
+    P = []
+    visites.append(r)
+    ajouter_pile(P,r)
+    while(not est_pile_vide(P)):
+        v = valeur_sommet_pile(P)
+        trouve = False # voisin de v non deja visite pas encore trouv ́e
+        for u in T.neighbors(v):
+            if (u not in visites) :
+                visites.append(u)
+                ajouter_pile(P,u)
+                trouve = True # voisin de v non deja visite trouv ́e
+                break
+        if not trouve :
+            enlever_sommet_pile(P)
+    return visites
+
+print("=========================== Exo 3 ===========================")
+print(parcours_prefixe(ArbreBin,1))
+
+# Ecrire une fonction qui affiche le nom de chaque sommet au moment o`u il est supprim ́e
+# de la pile. Ce type de parcours en profondeur d’un arbre binaire s’appelle un parcours
+# postfixe.
+
+def parcours_postfixe(T,r):
+    visites = []
+    P = []
+    visites.append(r)
+    ajouter_pile(P,r)
+    while(not est_pile_vide(P)):
+        v = valeur_sommet_pile(P)
+        trouve = False # voisin de v non deja visite pas encore trouv ́e
+        for u in T.neighbors(v):
+            if (u not in visites) :
+                visites.append(u)
+                ajouter_pile(P,u)
+                trouve = True # voisin de v non deja visite trouv ́e
+                break
+        if not trouve :
+            enlever_sommet_pile(P)
+            print(v)
+    return visites
+
+print("=========================== Exo 3 ===========================")
+print(parcours_postfixe(ArbreBin,1))
+
+
+
+
+# Ecrire une fonction qui affiche le nom de chaque sommet la premi`ere fois qu’on le
+# rencontre s’il n’a qu’un fils et la deuxi`eme fois s’il en a deux. Ce type de parcours en
+# profondeur d’un arbre binaire s’appelle un parcours infixe.
+
+def parcours_infixe(T,r):
+    visites = []
+    P = []
+    visites.append(r)
+    ajouter_pile(P,r)
+    while(not est_pile_vide(P)):
+        v = valeur_sommet_pile(P)
+        trouve = False # voisin de v non deja visite pas encore trouv ́e
+        for u in T.neighbors(v):
+            if (u not in visites) :
+                visites.append(u)
+                ajouter_pile(P,u)
+                trouve = True # voisin de v non deja visite trouv ́e
+                break
+        if len(list(T.neighbors(v))) == 1:
+            print(v)
+        if not trouve :
+            enlever_sommet_pile(P)
+            if len(list(T.neighbors(v))) == 2:
+                print(v)
+    return visites
+
+print("=========================== Exo 3 ===========================")
+print(parcours_infixe(ArbreBin,1))
+
+

1A/Maths/tp/Graphs/5_tp/tp5.py

@@ -0,0 +1,127 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+import numpy as np
+
+
+#! H=nx.Graph() #cr ́ee un graphe
+#! H.add_edge(0,1) #ajoute une arˆete entre les sommets 0 et 1
+#! H.add_edges_from([(3,0),(3,4)]) #ajoute les arˆetes d’une liste donn ́ee
+#! H.add_node("toto") #ajoute un sommet nomm ́e "toto"
+#! H.remove_node(s) #supprime le sommet s
+#! H.nodes #sommets du graphe (attention, pour en faire
+#! # une vraie liste Python,  ́ecrire: list(H.nodes))
+#! H.edges #arˆetes du graphe (attention, pour en faire
+#! # une vraie liste Python,  ́ecrire: list(H.edges))
+#! H.edges(s) #les arˆetes qui touchent le sommet s
+#! H.neighbors(s) #un it ́erateur sur les voisins du sommet s dans H
+#! # pour obtenir une liste,  ́ecrire: list(H.neighbors(s))
+#! H.nodes[s]["attri"] #acc`ede `a l’attribut nomm ́e "attri" du sommet s
+#! # (tant en lecture qu’en  ́ecriture)
+#! # exemple: H.nodes[s]["attri"]=2
+#! # ou alors print(H.nodes[s]["attri"])
+
+# Exercice 1
+
+##################################
+##Un graphe pour tester Dijkstra
+###################################
+print("Un graphe pour tester Dijkstra")
+G=nx.Graph()
+G.add_nodes_from(["A","B","C","D","E","F","G","H","I","J"],distance=None)
+print(G.nodes())
+G.add_edges_from([("A", "B", {"weight": 4}),("A", "C", {"weight": 2}),
+("A", "E", {"weight": 1}),("B", "F", {"weight": 3}),
+("C", "G", {"weight": 1}),("C", "H", {"weight": 2}),
+("D", "H", {"weight": 1}),("E", "J", {"weight": 5}),
+("F", "I", {"weight": 2}),("I", "J", {"weight": 5}),
+("H", "J", {"weight": 6})])
+print(G.edges())
+#########################
+print(G.edges[("A","B")]["weight"])
+print(G.nodes["A"]["distance"])
+#########################
+
+#? 1.
+# On rappelle ci-dessous l’algorithme de Dijkstra qui calcule les distances `a un sommet
+# source donn ́e :
+# Algorithme de Dijkstra pour le graphe G `a partir du sommet source s
+# • L repr ́esentera la fronti`ere. Contient initialement seulement s.
+# • La valeur de distance d est initialis ́ee `a d(s)=0 et `a d(v)=∞ pour
+# chaque autre sommet v
+# • Une liste T contient les sommets qui ont  ́et ́e compl`etement trait ́es.
+# Initialement T est vide.
+# • Tant que L n’est pas vide :
+# ⋆ choisir un sommet v dans L qui a une valeur de distance d(v)
+# minimale
+# ⋆ pour tout voisin w de v qui n’est pas dans T :
+# - si d(v) plus le poids p de l’arˆete (v,w) est inf ́erieur `a
+# d(w), on fixe d(w)=d(v)+p
+# - ajouter w `a L
+# ⋆ enlever v de L, ajouter v `a T
+# Impl ́ementez l’algorithme en suivant les  ́etapes suivantes :
+# 1.  ́Ecrire une fonction mise_a_jour_voisin(G,n,v) qui met `a jour la distance du som-
+# met v `a la source (v est suppos ́e voisin de n dans le graphe G) `a partir de celle du
+# sommet n (en supposant que la distance du sommet n `a la source est un nombre)
+
+def mise_a_jour_voisin(G,n,v):
+    G.nodes[v]["distance"]=G.edges[(n,v)]["weight"]
+
+print(mise_a_jour_voisin(G,"A","B"))
+
+# 2.
+# Ecrire une fonction choix_prochain_sommet(G,L), qui renvoie le sommet de la fronti`ere
+# L qui sera choisi pour la prochaine it ́eration de l’algorithme de Dijkstra.
+
+def choix_prochain_sommet(G,L):
+    return min(L,key=lambda x:G.nodes[x]["distance"])
+
+print(choix_prochain_sommet(G,["A","B","C","D","E","F","G","H","I","J"]))
+
+# 3.
+# Ecrire une fonction Dijkstra(G,s) qui d ́etermine les distances entre le sommet s et
+# tous les autres sommets dans le graphe valu ́e G.
+
+def Dijkstra(G,s):
+    L=[s]
+    G.nodes[s]["distance"]=0
+    while L!=[]:
+        v=choix_prochain_sommet(G,L)
+        for w in G.neighbors(v):
+            if w not in L:
+                if G.nodes[v]["distance"]+G.edges[(v,w)]["weight"]<G.nodes[w]["distance"]:
+                    G.nodes[w]["distance"]=G.nodes[v]["distance"]+G.edges[(v,w)]["weight"]
+                L.append(w)
+        L.remove(v)
+
+print(Dijkstra(G,"A"))
+
+# 4.Coder et tester l’algorithme de Floyd-Warshall, rappel ́e ci-dessous :
+# Algorithme de Floyd-Warshall pour le graphe G
+# • Les sommets sont ordonn ́es : s1 ... sn avec n le nombre de sommets
+# • On initialise une matrice D de taille n×n, o`u D(i, j) devra contenir la
+# distance entre le sommet si et le sommet sj . Pour toute arˆete entre si et
+# sj de poids pij , on fixe D(i, j) = pij , et pour tout i on fixe D(i, i) = 0.
+# Dans les autres cas, on fixe D(i, j) = ∞.
+# • Pour k allant de 1 `a n :
+# • Pour i allant de 1 `a n :
+# • Pour j allant de 1 `a n :
+# D(i, j) = min{D(i, j), D(i, k) + D(k, j)}
+# • Renvoyer D
+# Pourquoi n’est-t-il pas n ́ecessaire de copier la matrice D `a chaque  ́etape ? V ́erifier que
+# l’algorithme ne va pas  ́ecraser des donn ́ees importantes en cours de route
+
+def Floyd_Warshall(G):
+    n=len(G.nodes())
+    D=[[float("inf") for i in range(n)] for j in range(n)]
+    for i in range(n):
+        D[i][i]=0
+        for j in range(n):
+            if (i,j) in G.edges():
+                D[i][j]=G.edges[(i,j)]["weight"]
+    for k in range(n):
+        for i in range(n):
+            for j in range(n):
+                D[i][j]=min(D[i][j],D[i][k]+D[k][j])
+    return D
+
+print(Floyd_Warshall(G))

1A/Maths/tp/Graphs/6-7_tp/tp6-7.py

@@ -0,0 +1,88 @@
+import networkx as nx
+import matplotlib.pyplot as plt
+
+
+H=nx.Graph()
+H.add_edges_from([(1,2),(1,5),(2,3),(2,5),(3,4),(4,5),(4,6),(5,0),(0,1),
+(0,6),(3,6),(3,5),(5,6)])
+for s in H.nodes:
+    H.nodes[s]["couleur"] = 0
+
+
+def plus_petite_couleur_disponible(G,s):
+    couleurs = [G.nodes[v]["couleur"] for v in G.neighbors(s)]
+    for i in range(len(couleurs)+1):
+        if i not in couleurs:
+            return i
+        
+print(plus_petite_couleur_disponible(H,1))
+
+def coloration_gloutonne(G):
+    for s in G.nodes:
+        G.nodes[s]["couleur"] = plus_petite_couleur_disponible(G,s)
+    return G
+
+print(coloration_gloutonne(H).nodes.data())
+
+def afficher_graphe_colore(G):
+    nx.draw(G,with_labels=True,node_color=[G.nodes[v]["couleur"] for v in G.nodes])
+    plt.show()
+
+afficher_graphe_colore(H)
+
+# En option, on pourrait aussi afficher des vraies couleurs, prises au hasard, avec une
+# fonction afficher graphe colore vraies couleurs(G,c) o`u G est le graphe d ́ej`a co-
+# lori ́e et c est le nombre de couleurs. Pour tirer une couleur au hasard, il faut tirer au
+# hasard trois flottants (entre 0 et 1 chacun) repr ́esentant la proportion de rouge, vert, et
+# bleu, avec la fonction random.random() (il faut faire au pr ́ealable un import random).
+# Il faudra ensuite associer `a chaque num ́ero de couleur (entre 1 et c) de la coloration,
+# une couleur diff ́erente.
+# Par exemple, supposons que la liste L contient les sommets colori ́es avec une certaine
+# couleur (par exemple la couleur 1) et qu’on veut associer la couleur 1 `a la vraie couleur
+# d ́efinie par r=0.2, v=0.7, b=1, le code suivant affichera les sommets de L (et uniquement
+# ceux-ci) avec cette couleur :
+# dico_pos = nx.spring_layout(G)
+# nx.draw(G,pos=dico_pos,with_labels=True)
+# nx.draw_networkx_nodes(G, dico_pos, nodelist=L, node_color=[[r,v,b]])
+# plt.show()
+
+def afficher_graphe_colore_vraies_couleurs(G, c):
+    import random
+    for s in G.nodes:
+        G.nodes[s]["couleur"] = plus_petite_couleur_disponible(G,s)
+    dico_pos = nx.spring_layout(G)
+    nx.draw(G,pos=dico_pos,with_labels=True)
+    for i in range(c):
+        r = random.random()
+        v = random.random()
+        b = random.random()
+        nx.draw_networkx_nodes(G, dico_pos, nodelist=[s for s in G.nodes if G.nodes[s]["couleur"] == i], node_color=[[r,v,b]])
+    plt.show()
+
+afficher_graphe_colore_vraies_couleurs(H, 4)
+
+# Exercice 2. Algorithme de Welsh-Powell
+
+# 1. Avec combien de couleurs l’algorithme glouton de l’exercice 1 colorie-t-il l’arbre de la
+# figure ci-dessus (avec l’ordre donn ́e par les num ́eros) ? Et l’algorithme de Welsh-Powell
+# (en suivant l’ordre des degr ́es d ́ecroissants) ? Quel est le nombre optimal de couleurs ?
+
+# 4
+# Pour welshpowell c'est 2 differents
+
+# 2. Coder une fonction prochain sommet WP(G) qui,  ́etant donn ́e un graphe partiellement
+# color ́e, renvoie le prochain sommet color ́e par l’algorithme de Welsh-Powell (de degr ́e
+# maximum parmi les non-colori ́es).
+
+def prochain_sommet_WP(G):
+    degre_max = 0
+    sommet_max = None
+    for s in G.nodes:
+        if G.nodes[s]["couleur"] == 0 and G.degree[s] > degre_max:
+            degre_max = G.degree[s]
+            sommet_max = s
+    return sommet_max
+
+print(prochain_sommet_WP(H))
+
+QwwwWWWWW