formatte file

Dijkstra/algo.py

@@ -52,7 +52,7 @@ def dijkstra(graph: dict, start: any) -> tuple:
     """
     distances, predecesseur, unvisited = {}, {}, {}
     for sommet in graph:
-        distances[sommet] = float('inf')
+        distances[sommet] = float("inf")
         unvisited[sommet] = distances[sommet]
     distances[start] = 0
     while unvisited:
@@ -95,6 +95,7 @@ def reconstruire_chemin(predecesseur: dict, start: any, end: any) -> list:
     chemin.reverse()
     return chemin
 
+
 def solutions_dijkstra(graph: dict, start: any) -> dict:
     """elle renvoie le dictionnaire des noeud et distances grace au chemin
 
@@ -132,19 +133,22 @@ def solutions_dijkstra(graph: dict, start: any) -> dict:
         solutions[sommet] = {"distance": distances[sommet], "chemin": chemin}
     return solutions
 
+
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod(verbose=True)
     graph = {
-        'A': [('B', 4), ('C', 2)],
+        "A": [("B", 4), ("C", 2)],
-        'B': [('C', 5), ('D', 10)],
+        "B": [("C", 5), ("D", 10)],
-        'C': [('D', 3), ('E', 8)],
+        "C": [("D", 3), ("E", 8)],
-        'D': [('E', 4), ('F', 11)],
+        "D": [("E", 4), ("F", 11)],
-        'E': [('G', 6)],
+        "E": [("G", 6)],
-        'F': [('G', 2)],
+        "F": [("G", 2)],
-        'G': []
+        "G": [],
     }
-    solution = solutions_dijkstra(graph, 'A')
+    solution = solutions_dijkstra(graph, "A")
     for sommet, info in solution.items():
-        print(f"sommet: {sommet} ----- Distance: {info['distance']} ------- chemin: {info['chemin']}")
+        print(
-    
+            f"sommet: {sommet} ----- Distance: {info['distance']} ------- chemin: {info['chemin']}"
+        )

Partie2/Eleve/Projet/control.py

@@ -2,6 +2,7 @@ from flask import Flask, render_template
 
 app = Flask(__name__)
 
-@app.route('/')
+
+@app.route("/")
 def index():
-    return render_template('index.html')
+    return render_template("index.html")

TDliste2liste/exercice1.py

@@ -6,6 +6,7 @@ def appartient(elt,tableau):
             continue
     return False
 
+
 if __name__ == "__main__":
     print(appartient(5, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
     print(appartient(5, [1, 2, 3, 4, 6, 7, 8, 9, 10]))

TDliste2liste/exercice2.py

@@ -7,6 +7,7 @@ def max_local(tableau):
             continue
     return maximum
 
+
 def indice_max(tableau):
     maximum = max_local(tableau)
     for i in range(len(tableau)):
@@ -15,6 +16,7 @@ def indice_max(tableau):
         else:
             continue
 
+
 if __name__ == "__main__":
     l1 = [0, 2, 3, 4, 5, 6, 7, 8, 9, 90, 91, 59, 1]
     print(max_local(l1))

TDliste2liste/exercice3.py

@@ -1,8 +1,11 @@
 def cree_tableau_n_m(n, m):
     return [[0 for _ in range(m)] for _ in range(n)]
 
+
 def cree_tableau_carre_n(n):
     return [[0 for _ in range(n)] for _ in range(n)]
+
+
 if __name__ == "__main__":
     print(cree_tableau_n_m(3, 5))
     print(cree_tableau_carre_n(5))

TDliste2liste/exercice4.py

@@ -8,5 +8,6 @@ def cree_carre_entier_1_n_carre(n):
             compteur += 1
         carre.append(ligne)
     return carre
-print(cree_carre_entier_1_n_carre(8))
 
+
+print(cree_carre_entier_1_n_carre(8))

TDliste2liste/exercice5.py

@@ -2,8 +2,11 @@ def transpose(carre):
     n = len(carre)  # Nombre de lignes (ou colonnes, car c'est une matrice carrée)
     return [[carre[j][i] for j in range(n)] for i in range(n)]
 
+
 def transpose_en_place(carre):
     n = len(carre)  # Nombre de lignes (ou colonnes)
     for i in range(n):
-        for j in range(i + 1, n):  # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés
+        for j in range(
+            i + 1, n
+        ):  # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés
             carre[i][j], carre[j][i] = carre[j][i], carre[i][j]  # Échange des éléments

TDliste2liste/exercice6.py

@@ -1,9 +1,11 @@
 def diag_1(carre):
     return [carre[i][i] for i in range(len(carre))]
 
+
 def diag_2(carre):
     n = len(carre)
     return [carre[i][n - 1 - i] for i in range(n)]
 
+
 def colonne(j, carre):
     return [carre[i][j] for i in range(len(carre))]

casse-brique/main.py

@@ -23,6 +23,7 @@ pygame.display.set_caption("Casse-Brique Auto-Play")
 clock = pygame.time.Clock()
 FPS = 100
 
+
 # Fonction d'affichage du menu de démarrage
 def show_menu():
     menu_running = True
@@ -39,7 +40,9 @@ def show_menu():
 
         # Affichage du titre
         title_surface = title_font.render("Casse-Brique", True, WHITE)
-        title_rect = title_surface.get_rect(center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 3))
+        title_rect = title_surface.get_rect(
+            center=(SCREEN_WIDTH // 2, SCREEN_HEIGHT // 3)
+        )
         screen.blit(title_surface, title_rect)
 
         # Dessiner le bouton "Jouer"
@@ -60,6 +63,7 @@ def show_menu():
 
         pygame.display.flip()
 
+
 # Fonction principale du jeu
 def game_loop():
     # Paramètres de la raquette
@@ -72,13 +76,15 @@ def game_loop():
     # Paramètres de la balle
     ball_radius = 10
     # Liste de balles (initialement une seule)
-    balls = [{
+    balls = [
-        'x': SCREEN_WIDTH / 2,
+        {
-        'y': SCREEN_HEIGHT / 2,
+            "x": SCREEN_WIDTH / 2,
-        'radius': ball_radius,
+            "y": SCREEN_HEIGHT / 2,
-        'speed_x': 9 * random.choice([-1, 1]),
+            "radius": ball_radius,
-        'speed_y': -9
+            "speed_x": 9 * random.choice([-1, 1]),
-    }]
+            "speed_y": -9,
+        }
+    ]
 
     # Paramètres des briques
     BRICK_ROWS = 5  # nombre de lignes de briques
@@ -94,7 +100,9 @@ def game_loop():
         for col in range(BRICK_COLUMNS):
             brick_x = col * BRICK_WIDTH + brick_padding
             brick_y = row * (BRICK_HEIGHT + brick_padding) + brick_padding
-            brick_rect = pygame.Rect(brick_x, brick_y, BRICK_WIDTH - brick_padding * 2, BRICK_HEIGHT)
+            brick_rect = pygame.Rect(
+                brick_x, brick_y, BRICK_WIDTH - brick_padding * 2, BRICK_HEIGHT
+            )
             brick_row.append(brick_rect)
         bricks.append(brick_row)
 
@@ -112,7 +120,7 @@ def game_loop():
         # On cherche une balle qui descend (speed_y > 0), sinon on prend la première balle
         target_ball = None
         for ball in balls:
-            if ball['speed_y'] > 0:
+            if ball["speed_y"] > 0:
                 target_ball = ball
                 break
         if target_ball is None:
@@ -120,9 +128,9 @@ def game_loop():
         # Calcul du centre de la raquette
         paddle_center = paddle_x + PADDLE_WIDTH / 2
         # Si le centre est trop à gauche ou à droite de la balle cible, on déplace la raquette
-        if paddle_center < target_ball['x'] - 5:
+        if paddle_center < target_ball["x"] - 5:
             paddle_x += paddle_speed
-        elif paddle_center > target_ball['x'] + 5:
+        elif paddle_center > target_ball["x"] + 5:
             paddle_x -= paddle_speed
 
         # Limiter la raquette à l'intérieur de l'écran
@@ -135,31 +143,40 @@ def game_loop():
 
         # Mise à jour de la position des balles
         for ball in balls:
-            ball['x'] += ball['speed_x']
+            ball["x"] += ball["speed_x"]
-            ball['y'] += ball['speed_y']
+            ball["y"] += ball["speed_y"]
 
             # Collision avec les murs latéraux
-            if ball['x'] - ball['radius'] <= 0 or ball['x'] + ball['radius'] >= SCREEN_WIDTH:
+            if (
-                ball['speed_x'] *= -1
+                ball["x"] - ball["radius"] <= 0
+                or ball["x"] + ball["radius"] >= SCREEN_WIDTH
+            ):
+                ball["speed_x"] *= -1
 
             # Collision avec le haut de l'écran
-            if ball['y'] - ball['radius'] <= 0:
+            if ball["y"] - ball["radius"] <= 0:
-                ball['speed_y'] *= -1
+                ball["speed_y"] *= -1
 
             # Création du rectangle de la balle pour la détection des collisions
-            ball_rect = pygame.Rect(ball['x'] - ball['radius'], ball['y'] - ball['radius'],
+            ball_rect = pygame.Rect(
-                                    ball['radius'] * 2, ball['radius'] * 2)
+                ball["x"] - ball["radius"],
+                ball["y"] - ball["radius"],
+                ball["radius"] * 2,
+                ball["radius"] * 2,
+            )
 
             # Collision entre la balle et la raquette (uniquement si la balle descend)
-            if ball_rect.colliderect(paddle_rect) and ball['speed_y'] > 0:
+            if ball_rect.colliderect(paddle_rect) and ball["speed_y"] > 0:
-                ball['speed_y'] *= -1  # Inversion de la vitesse verticale
+                ball["speed_y"] *= -1  # Inversion de la vitesse verticale
-                offset = (ball['x'] - (paddle_x + PADDLE_WIDTH / 2)) / (PADDLE_WIDTH / 2)
+                offset = (ball["x"] - (paddle_x + PADDLE_WIDTH / 2)) / (
-                ball['speed_x'] = 4 * offset
+                    PADDLE_WIDTH / 2
+                )
+                ball["speed_x"] = 4 * offset
 
                 # Création d'une nouvelle balle lors de la collision
                 new_ball = ball.copy()
-                new_ball['speed_x'] *= -1
+                new_ball["speed_x"] *= -1
-                new_ball['speed_x'] += random.choice([-1, 1])
+                new_ball["speed_x"] += random.choice([-1, 1])
                 nouvelles_balles.append(new_ball)
 
             # Collision entre la balle et les briques
@@ -168,7 +185,7 @@ def game_loop():
                 for brick in row:
                     if brick and ball_rect.colliderect(brick):
                         hit_brick = brick
-                        ball['speed_y'] *= -1  # Inversion de la vitesse verticale
+                        ball["speed_y"] *= -1  # Inversion de la vitesse verticale
                         break
                 if hit_brick:
                     row[row.index(hit_brick)] = None
@@ -180,27 +197,33 @@ def game_loop():
         # Gestion des collisions entre balles
         for i in range(len(balls)):
             for j in range(i + 1, len(balls)):
-                dx = balls[i]['x'] - balls[j]['x']
+                dx = balls[i]["x"] - balls[j]["x"]
-                dy = balls[i]['y'] - balls[j]['y']
+                dy = balls[i]["y"] - balls[j]["y"]
                 distance = math.sqrt(dx * dx + dy * dy)
-                if distance < balls[i]['radius'] + balls[j]['radius']:
+                if distance < balls[i]["radius"] + balls[j]["radius"]:
                     # Échange des vitesses pour simuler une collision élastique
-                    balls[i]['speed_x'], balls[j]['speed_x'] = balls[j]['speed_x'], balls[i]['speed_x']
+                    balls[i]["speed_x"], balls[j]["speed_x"] = (
-                    balls[i]['speed_y'], balls[j]['speed_y'] = balls[j]['speed_y'], balls[i]['speed_y']
+                        balls[j]["speed_x"],
+                        balls[i]["speed_x"],
+                    )
+                    balls[i]["speed_y"], balls[j]["speed_y"] = (
+                        balls[j]["speed_y"],
+                        balls[i]["speed_y"],
+                    )
                     # Ajustement des positions pour éviter la superposition
-                    overlap = balls[i]['radius'] + balls[j]['radius'] - distance
+                    overlap = balls[i]["radius"] + balls[j]["radius"] - distance
                     if distance != 0:
                         nx = dx / distance
                         ny = dy / distance
                     else:
                         nx, ny = 1, 0
-                    balls[i]['x'] += nx * overlap / 2
+                    balls[i]["x"] += nx * overlap / 2
-                    balls[i]['y'] += ny * overlap / 2
+                    balls[i]["y"] += ny * overlap / 2
-                    balls[j]['x'] -= nx * overlap / 2
+                    balls[j]["x"] -= nx * overlap / 2
-                    balls[j]['y'] -= ny * overlap / 2
+                    balls[j]["y"] -= ny * overlap / 2
 
         # Suppression des balles qui sortent par le bas de l'écran
-        balls = [ball for ball in balls if ball['y'] - ball['radius'] <= SCREEN_HEIGHT]
+        balls = [ball for ball in balls if ball["y"] - ball["radius"] <= SCREEN_HEIGHT]
         if not balls:
             print("Game Over!")
             running = False
@@ -216,15 +239,17 @@ def game_loop():
 
         # Dessiner les balles
         for ball in balls:
-            pygame.draw.circle(screen, WHITE, (int(ball['x']), int(ball['y'])), ball['radius'])
+            pygame.draw.circle(
+                screen, WHITE, (int(ball["x"]), int(ball["y"])), ball["radius"]
+            )
 
         pygame.display.flip()
 
     pygame.quit()
     sys.exit()
 
+
 # Programme principal
 if __name__ == "__main__":
     show_menu()  # Afficher le menu de démarrage
     game_loop()  # Lancer le jeu
-

cesar/chiffrement.py

@@ -1,13 +1,16 @@
 import string
 
+
 def load_file():
     with open("message.txt", "r", encoding="utf-8") as f:
         content = f.read()
     return content
 
+
 lower_case = string.ascii_lowercase
 upper_case = string.ascii_uppercase
 
+
 def dechiffrer(content, step):
     resultat = ""
 
@@ -23,6 +26,7 @@ def dechiffrer(content, step):
 
     return resultat
 
+
 contenu = load_file()
 texte_dechiffre = dechiffrer(contenu, step=17)
 

crypto/algo.py

@@ -7,18 +7,22 @@ def est_premier(n):
             return False
     return True
 
+
 def liste_premier_inf(n):
     return [i for i in range(2, n + 1) if est_premier(i)]
 
+
 def pgcd(a, b):
     while b:
         a, b = b, a % b
     return a
 
+
 def cle_publique_possible(a, b):
     n = a * b
     return [i for i in range(1, n) if pgcd(i, n) == 1]
 
+
 def inverse(e, n):
     t, newt = 0, 1
     r, newr = n, e
@@ -32,17 +36,23 @@ def inverse(e, n):
         t += n
     return t
 
+
 def chaine_en_liste(chaine):
     return [ord(c) for c in chaine]
 
+
 def chiffre(e, N, liste):
     return [pow(x, e, N) for x in liste]
 
+
 def dechiffre(d, N, liste):
     return [pow(x, d, N) for x in liste]
 
+
 def liste_en_chaine(liste):
-    return ''.join(chr(x) for x in liste)
+    return "".join(chr(x) for x in liste)
+
+
 cle = 17873
 a, b = 61, 53
 N = a * b

ensembles_dynamiques/TP/_collection.py

@@ -13,6 +13,7 @@
 # Un ensemble est une collection d'éléments, d'occurence unique.
 # Les fonctions sont implémentées dans le paradigme fonctionnel.
 
+
 def initialiser_ensemble():
     """
     Construit un ensemble vide.
@@ -31,6 +32,7 @@ def initialiser_ensemble():
     """
     return set()
 
+
 def est_ensemble_vide(ensemble):
     """
     Teste si l'ensemble est vide.
@@ -46,6 +48,7 @@ def est_ensemble_vide(ensemble):
     """
     return len(ensemble) == 0
 
+
 def copier_ensemble(ensemble):
     """
     Construit la copie d'un ensemble.
@@ -67,6 +70,7 @@ def copier_ensemble(ensemble):
         resultat.add(_)
     return resultat
 
+
 def ajouter(ensemble, element):
     """
     Ajoute un element à la copie d'un ensemble
@@ -88,6 +92,7 @@ def ajouter(ensemble, element):
     resultat.add(element)
     return resultat
 
+
 def supprimer(ensemble, element):
     """
     Construire une copie de l'ensemble privé d'un élément.
@@ -107,6 +112,7 @@ def supprimer(ensemble, element):
             resultat = ajouter(resultat, _)
     return resultat
 
+
 def rechercher(ensemble, cle, critere=lambda x, y: x == y):
     """
     Construit la sous-collection constituée des éléments d'un ensemble
@@ -132,6 +138,7 @@ def rechercher(ensemble, cle, critere = lambda x, y: x==y):
             resultat = ajouter(resultat, _)
     return resultat
 
+
 def supprimer_critere(ensemble, cle, critere):
     """
     Construit la collection des éléments d'un ensemble,
@@ -157,6 +164,7 @@ def supprimer_critere(ensemble, cle, critere):
         resultat = supprimer(resultat, _)
     return resultat
 
+
 def lister(ensemble, affichage=print):
     """
     Afficher le contenu d'un ensemble,
@@ -180,6 +188,5 @@ def lister(ensemble, affichage=print):
     return None
 
 
-
 if __name__ == "__main__":
     pass

ensembles_dynamiques/TP/_collection_list.py

@@ -13,6 +13,7 @@
 # Un ensemble est une collection d'éléments, d'occurence unique.
 # Les fonctions sont implémentées dans le paradigme fonctionnel.
 
+
 def initialiser_ensemble():
     """
     Construit un ensemble vide.
@@ -31,6 +32,7 @@ def initialiser_ensemble():
     """
     return list()
 
+
 def est_ensemble_vide(ensemble):
     """
     Teste si l'ensemble est vide.
@@ -46,6 +48,7 @@ def est_ensemble_vide(ensemble):
     """
     return len(ensemble) == 0
 
+
 def copier_ensemble(ensemble):
     """
     Construit la copie d'un ensemble.
@@ -64,6 +67,7 @@ def copier_ensemble(ensemble):
     """
     return ensemble[:]
 
+
 def ajouter(ensemble, element):
     """
     Ajoute un element à la copie d'un ensemble
@@ -85,6 +89,7 @@ def ajouter(ensemble, element):
     copie.append(element)
     return copie
 
+
 def supprimer(ensemble, element):
     """
     Construire une copie de l'ensemble privé d'un élément.
@@ -101,6 +106,7 @@ def supprimer(ensemble, element):
     resultat = ensemble[:]
     return resultat.remove(element)
 
+
 def rechercher(ensemble, cle, critere=lambda x, y: x == y):
     """
     Construit la sous-collection constituée des éléments d'un ensemble
@@ -122,6 +128,7 @@ def rechercher(ensemble, cle, critere = lambda x, y: x==y):
     """
     return [element for element in ensemble if critere(element, cle)]
 
+
 def supprimer_critere(ensemble, cle, critere):
     """
     Construit la collection des éléments d'un ensemble,
@@ -143,6 +150,7 @@ def supprimer_critere(ensemble, cle, critere):
     """
     return [element for element in ensemble if not critere(element, cle)]
 
+
 def lister(ensemble, affichage=print):
     """
     Afficher le contenu d'un ensemble,
@@ -163,5 +171,7 @@ def lister(ensemble, affichage=print):
     """
     for item in ensemble:
         affichage(item)
+
+
 if __name__ == "__main__":
     pass

ensembles_dynamiques/TP/_sommets.py

@@ -15,6 +15,7 @@
 # - altitude : INT, altitude en m
 # - massif : STR
 
+
 def creer_sommet(nom, altitude, massif):
     """
     Construit le tuple sommet.
@@ -35,6 +36,7 @@ def creer_sommet(nom, altitude, massif):
     """
     return (nom, altitude, massif)
 
+
 def altitude_en_m(altitude):
     """
     Conversion de l'altitude en entier ("2 062 m" -> 2062)
@@ -51,12 +53,13 @@ def altitude_en_m(altitude):
     Effet de bord :
     - aucun
     """
-    tmp = ''
+    tmp = ""
     for symbole in altitude:
-        if not(symbole in ' m'):
+        if not (symbole in " m"):
             tmp += symbole
     return int(tmp)
 
+
 def creer_sommet_csv(ligne, massif):
     """
     Construit un sommet à partir d'une ligne du fichier csv.
@@ -74,9 +77,10 @@ def creer_sommet_csv(ligne, massif):
     Effet de bord :
     - aucun
     """
-    nom, alt = ligne.rstrip().split(',')
+    nom, alt = ligne.rstrip().split(",")
     return creer_sommet(nom, altitude_en_m(alt), massif)
 
+
 def afficher(sommet):
     """
     Affichage formatté du sommet.
@@ -94,9 +98,10 @@ def afficher(sommet):
     - Affichage sur la sortie standard
     """
     nom, altitude, massif = sommet
-    print(f'{nom:35s}\t[{massif}]\n\taltitude : {altitude} m')
+    print(f"{nom:35s}\t[{massif}]\n\taltitude : {altitude} m")
     return None
 
+
 def nom(sommet):
     """
     Consulte le nom d'un sommet
@@ -115,6 +120,7 @@ def nom(sommet):
     """
     return sommet[0]
 
+
 def altitude(sommet):
     """
     Consulte l'altitude d'un sommet
@@ -133,6 +139,7 @@ def altitude(sommet):
     """
     return sommet[1]
 
+
 def massif(sommet):
     """
     Consulte le massif d'un sommet
@@ -151,6 +158,7 @@ def massif(sommet):
     """
     return sommet[2]
 
+
 def coincide_nom(sommet, motif):
     """
     Compare le nom du sommet au motif
@@ -171,5 +179,6 @@ def coincide_nom(sommet, motif):
     nom_sommet = nom(sommet)
     return (len(motif) <= len(nom_sommet)) and (nom_sommet[: len(motif)] == motif)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     pass

ensembles_dynamiques/TP/_sommets_dict.py

@@ -16,6 +16,7 @@
 # - altitude : INT, altitude en m
 # - massif : STR
 
+
 def creer_sommet(nom, altitude, massif):
     """
     Construit le dico sommet.
@@ -34,14 +35,11 @@ def creer_sommet(nom, altitude, massif):
     Effet de bord :
     - aucun
     """
-    sommet = {
+    sommet = {"Nom": nom, "Altitude": altitude, "Massif": massif}
-            "Nom": nom,
-            "Altitude": altitude,
-            "Massif": massif
-    }
 
     return sommet
 
+
 def altitude_en_m(altitude):
     """
     Conversion de l'altitude en entier ("2 062 m" -> 2062)
@@ -58,12 +56,13 @@ def altitude_en_m(altitude):
     Effet de bord :
     - aucun
     """
-    tmp = ''
+    tmp = ""
     for symbole in altitude:
-        if not(symbole in ' m'):
+        if not (symbole in " m"):
             tmp += symbole
     return int(tmp)
 
+
 def creer_sommet_csv(ligne, massif):
     """
     Construit un sommet à partir d'une ligne du fichier csv.
@@ -81,9 +80,10 @@ def creer_sommet_csv(ligne, massif):
     Effet de bord :
     - aucun
     """
-    nom, alt = ligne.rstrip().split(',')
+    nom, alt = ligne.rstrip().split(",")
     return creer_sommet(nom, altitude_en_m(alt), massif)
 
+
 def afficher(sommet):
     """
     Affichage formatté du sommet.
@@ -101,7 +101,9 @@ def afficher(sommet):
     - Affichage sur la sortie standard
     """
 
-    print(f"{sommet['Nom']:35s}\t[{sommet['Massif']}]\n\taltitude : {sommet['Altitude']} m")
+    print(
+        f"{sommet['Nom']:35s}\t[{sommet['Massif']}]\n\taltitude : {sommet['Altitude']} m"
+    )
 
 
 def nom(sommet):
@@ -121,6 +123,8 @@ def nom(sommet):
     - aucun
     """
     return sommet["Nom"]
+
+
 def altitude(sommet):
     """
     Consulte l'altitude d'un sommet
@@ -137,7 +141,9 @@ def altitude(sommet):
     Effet de bord :
     - aucun
     """
-    return sommet['Altitude']
+    return sommet["Altitude"]
+
+
 def massif(sommet):
     """
     Consulte le massif d'un sommet
@@ -155,6 +161,8 @@ def massif(sommet):
     - aucun
     """
     return sommet["Massif"]
+
+
 def coincide_nom(sommet, motif):
     """
     Compare le nom du sommet au motif
@@ -176,5 +184,6 @@ def coincide_nom(sommet, motif):
     nom_sommet = nom(sommet)
     return (len(motif) <= len(nom_sommet)) and (nom_sommet[: len(motif)] == motif)
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     pass

ensembles_dynamiques/TP/main.py

@@ -16,7 +16,8 @@ import _sommets as som
 # Le module _collection définit nos ENSEMBLES
 # Le module _sommets définit nos SOMMETS
 
-def file_2_set(fichier='./data/Chartreuse.csv'):
+
+def file_2_set(fichier="./data/Chartreuse.csv"):
     """
     Lecture du fichier csv contenant les caractéristiques des sommets.
 
@@ -41,6 +42,7 @@ def file_2_set(fichier='./data/Chartreuse.csv'):
             ligne = src.readline()
     return resultat
 
+
 def rechercher(ensemble, motif):
     """
     Recherche les sommets de la collection dont le nom
@@ -62,6 +64,7 @@ def rechercher(ensemble, motif):
     return col.rechercher(ensemble, motif, som.coincide_nom)
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
-    col.lister(col.supprimer_critere(file_2_set(), 'Grand', som.coincide_nom), \
+    col.lister(
-            som.afficher)
+        col.supprimer_critere(file_2_set(), "Grand", som.coincide_nom), som.afficher
+    )

fibonacci/code1.py

@@ -1,4 +1,6 @@
 import numpy as np
+
+
 def fibobo(n):
     if n <= 1:
         return n
@@ -7,7 +9,10 @@ def fibobo(n):
 
 print(fibobo(30))
 
+
 def fibibi(n):
     fibi = np.array([[1, 1], [1, 0]])
     return np.linalg.matrix_power(fibi, n)[0][-1]
+
+
 print(fibibi(100))

fibonacci/complex.py

@@ -3,18 +3,23 @@ import time
 import matplotlib.pyplot as plt
 import math
 
+
 # Définir les fonctions
 def fibobo(n):
     if n <= 1:
         return n
     return fibobo(n - 1) + fibobo(n - 2)
 
+
 def fibibi(n):
     fibi = np.array([[1, 1], [1, 0]])
     return np.linalg.matrix_power(fibi, n)[0][-1]
 
+
 # Benchmark des temps d'exécution
-n_values_recursive = range(1, 35, 1)  # Plage raisonnable pour fibobo (approche récursive)
+n_values_recursive = range(
+    1, 35, 1
+)  # Plage raisonnable pour fibobo (approche récursive)
 n_values_matrix = range(1, 50, 1)  # Limiter n pour éviter les dépassements avec 2^n
 
 # Temps pour fibobo
@@ -39,10 +44,10 @@ exp_2_n = [2**n for n in n_values_matrix]
 plt.figure(figsize=(12, 8))
 
 # Graphe des temps pour fibobo
-plt.plot(n_values_recursive, times_recursive, label="fibobo (récursif)", marker='o')
+plt.plot(n_values_recursive, times_recursive, label="fibobo (récursif)", marker="o")
 
 # Graphe des temps pour fibibi
-plt.plot(n_values_matrix, times_matrix, label="fibibi (matriciel)", marker='s')
+plt.plot(n_values_matrix, times_matrix, label="fibibi (matriciel)", marker="s")
 
 # Ajouter log(n) pour comparaison simple
 plt.plot(n_values_matrix, log_n, label="log(n)", linestyle="--")
@@ -51,7 +56,7 @@ plt.plot(n_values_matrix, log_n, label="log(n)", linestyle="--")
 plt.plot(n_values_matrix, exp_2_n, label="2^n", linestyle=":")
 
 # Ajuster l'échelle de l'axe y pour éviter les dépassements
-plt.yscale('log')  # Échelle logarithmique pour mieux visualiser les variations
+plt.yscale("log")  # Échelle logarithmique pour mieux visualiser les variations
 plt.ylim(1e-6, 1e10)  # Limiter les valeurs extrêmes
 
 plt.title("Comparaison des performances avec log(n) et 2^n")

file/old/LSC.py

@@ -6,9 +6,9 @@ Elle met à distribution cette structure de données et son interface.
 @author: L. JOANNIC
 """
 
-
 # ############################################################################
 
+
 class Liste_Simplement_Chainee(object):
     """
     Classe des Listes Simplement Chainees.
@@ -45,7 +45,7 @@ class Liste_Simplement_Chainee(object):
             Vrai ssi la liste est vide.
 
         """
-        return (self._tete is None)
+        return self._tete is None
 
     def ajouter_en_tete(self, element):
         """
@@ -95,6 +95,7 @@ class Liste_Simplement_Chainee(object):
 
 # ############################################################################
 
+
 def creer_liste_vide():
     """
     Créer une liste simplement chainee vide.
@@ -216,16 +217,18 @@ def afficher_liste(liste, taille=-1):
     """
     reste = liste
     compteur = 0
-    print('+-----\n|')
+    print("+-----\n|")
     while not (est_vide(reste)) and (taille == -1 or compteur < taille):
-        print('+- {}\n|'.format(str(tete(reste))))
+        print("+- {}\n|".format(str(tete(reste))))
         reste = queue(reste)
         compteur += 1
-    print('+-----')
+    print("+-----")
     return None
 
+
 # ############################################################################
 
+
 class Maillon(object):
     """
     Classe des Maillons d'une Liste Simplement Chainee.

file/old/file.py

@@ -7,6 +7,7 @@ def creer_file_vide():
     """
     return []
 
+
 def est_vide(file):
     """
     Vérifie si une file est vide.
@@ -19,6 +20,7 @@ def est_vide(file):
     """
     return len(file) == 0
 
+
 def enfiler(file, elt):
     """
     Ajoute un élément à la fin de la file.
@@ -32,6 +34,7 @@ def enfiler(file, elt):
     """
     return file.append(elt)
 
+
 def defiler(file: list):
     """
     Retire et renvoie le premier élément de la file.
@@ -44,6 +47,7 @@ def defiler(file: list):
     """
     return file[1:]
 
+
 def peak(file: list):
     """
     Renvoie l'élément en tête de la file sans le retirer.
@@ -55,4 +59,3 @@ def peak(file: list):
         L'élément en tête de la file.
     """
     return file[0]
-

file/old/file_LSC.py

@@ -1,4 +1,5 @@
 import LSC as lifo
 
+
 def creer_liste_vide():
     return lifo.cr

fonctions_tri/partitionement.py

@@ -1,5 +1,6 @@
 from typing import Any
 
+
 def partitionement(liste: list[Any], debut, fin):
     pivot = liste[debut]
     gauche = debut + 1
@@ -25,36 +26,3 @@ def exchange(liste, indx_g, indx_d):
 
 l = [12, 4, 0, 44, 27]
 print(partitionement(l, 0, len(l) - 1))
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-

graphes/DS_possible/main.py

@@ -4,9 +4,11 @@ graphe = {
     "node3": ["node5"],
     "node5": ["node5", "node6"],
     "node4": ["node1", "node5"],
-    "node6": []
+    "node6": [],
 }
 print(graphe["node1"])
+
+
 def bfs(graphe, start_node):
     queue = [start_node]
 
@@ -21,7 +23,4 @@ def bfs(graphe, start_node):
                     queue.append(neighbor)
 
 
-
-
-
 bfs(graphe, "node1")

graphes/homework_wednesday.py

@@ -2,8 +2,9 @@
 
 import heapq
 
+
 def dijkstra(graph, source):
-    distances = {node: float('inf') for node in graph}
+    distances = {node: float("inf") for node in graph}
     distances[source] = 0
 
     previous = {node: None for node in graph}
@@ -25,6 +26,7 @@ def dijkstra(graph, source):
 
     return distances, previous
 
+
 def reconstruct_path(previous, start, end):
     path = []
     node = end
@@ -34,13 +36,14 @@ def reconstruct_path(previous, start, end):
     path.reverse()
     return path
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     graph = {
         "R1": [("R2", 1)],
         "R2": [("R3", 1), ("R5", 10)],
         "R3": [("R4", 1), ("R5", 1)],
         "R5": [("R4", 10)],
-        "R4": []
+        "R4": [],
     }
 
     source = "R1"
@@ -52,4 +55,3 @@ if __name__ == '__main__':
 
     path = reconstruct_path(previous, source, destination)
     print("Shortest path from", source, "to", destination, ":", path)
-

graphes/leaudibidon/Water_jug.py

@@ -2,7 +2,6 @@
 # -*- Coding: utf-8 -*-
 
 
-
 class Graphe_Oriente(object):
     """
     Classe des Graphes Orientés (GO).
@@ -83,10 +82,19 @@ def construire_chemins(graphe, depart):
     while len(file) > 0:
         sommet = file.pop(0)  # retire le premier element de la file -> FIFO
         for voisin in graphe.voisins[sommet]:  # Parcours tous les voisins du sommet
-			if voisin not in resultat: # Verifie que cette partie de l arbre (ou du graphe) n a pas deja ete explorer
+            if (
-				distance = resultat[sommet][0] + 1 # Definie distance -> Distance du dernier sommet + 1
+                voisin not in resultat
-				resultat[voisin] = (distance, sommet) # Insere le nouveau sommet dans le dictionnaire
+            ):  # Verifie que cette partie de l arbre (ou du graphe) n a pas deja ete explorer
-				file.append(voisin) # Permet la reiteration de la boucle a partir de se sommet
+                distance = (
+                    resultat[sommet][0] + 1
+                )  # Definie distance -> Distance du dernier sommet + 1
+                resultat[voisin] = (
+                    distance,
+                    sommet,
+                )  # Insere le nouveau sommet dans le dictionnaire
+                file.append(
+                    voisin
+                )  # Permet la reiteration de la boucle a partir de se sommet
 
     return resultat
 
@@ -107,13 +115,19 @@ def reconstruire_chemin_vers(dico_chemins, *arrivee):
     chemins = list()
     cibles = arrivee  # Creer une liste avec les sommets a remonter
     if len(cibles) == 0:
-		return list(dico_chemins.keys()) # si la liste est vide, on renvoie les chemins (sans leurs attributs)
+        return list(
+            dico_chemins.keys()
+        )  # si la liste est vide, on renvoie les chemins (sans leurs attributs)
     for sommet in cibles:
         sous_chemin = []
         current = sommet
         while current is not None:
-			sous_chemin.insert(0, current) # on insere le sommet au début de la liste (permet de maintenir l ordre)
+            sous_chemin.insert(
-			current = dico_chemins[current][1] # on change current avec le sommet predesseceur pour que la boucle continue
+                0, current
+            )  # on insere le sommet au début de la liste (permet de maintenir l ordre)
+            current = dico_chemins[current][
+                1
+            ]  # on change current avec le sommet predesseceur pour que la boucle continue
         chemins.append(sous_chemin)
     return chemins
 
@@ -194,6 +208,7 @@ def transvaser(source, destination, etat, capacites):
 
 # FONCTION LIEES AU GRAPHE DU WATER_JUG
 
+
 # Pour construire les etats
 def produit_cartesien(*listes):
     """
@@ -306,31 +321,37 @@ def atteindre(quantite, graphe_water_jug, depart=None, plus_court=False):
 def main():
     solutions = atteindre(4, creer_water_jug(3, 5))
 
-	for (sommet_final, nb_etapes, chemin) in solutions:
+    for sommet_final, nb_etapes, chemin in solutions:
         print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes")
         print(affichage_chemin(chemin))
         print("--------------------------------------")
 
+
 def question1():
 
     print("Non pas tous les quantités de litres peuvent être représenter comme 6l.")
+
+
 def question2():
     for i in range(10):
         resolutions = atteindre(i, creer_water_jug(3, 5), None, True)
-		for (sommet_final, nb_etapes, chemin) in resolutions:
+        for sommet_final, nb_etapes, chemin in resolutions:
-			print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes")
-			print(affichage_chemin(chemin))
-			print("--------------------------------------")
-def question3():
-	solution = atteindre(4,creer_water_jug(3,5),None,True)
-	for (sommet_final, nb_etapes, chemin) in solution:
             print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes")
             print(affichage_chemin(chemin))
             print("--------------------------------------")
 
+
+def question3():
+    solution = atteindre(4, creer_water_jug(3, 5), None, True)
+    for sommet_final, nb_etapes, chemin in solution:
+        print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes")
+        print(affichage_chemin(chemin))
+        print("--------------------------------------")
+
+
 def question4():
     solution = atteindre(1, creer_water_jug(3, 5, 9), None, True)
-	for (sommet_final, nb_etapes, chemin) in solution:
+    for sommet_final, nb_etapes, chemin in solution:
         print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes")
         print(affichage_chemin(chemin))
         print("--------------------------------------")
@@ -338,6 +359,7 @@ def question4():
 
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod(verbose=True)
     main()
     question1()

graphes/leaudibidon/correction.py

@@ -14,9 +14,7 @@ def produit_cartesien(*listes):
     return produit_cartesien(liste1, produit_cartesien(*reste))
 
 
-
 liste1 = [(_,) for _ in range(3)]
 liste2 = [(_,) for _ in range(5)]
 liste3 = [(_,) for _ in range(8)]
 print(produit_cartesien(liste1, liste2))
-	

graphes/leaudibidon/main.py

@@ -16,16 +16,20 @@ class leaudibidon(object):
         b5.quantity = 0
         print("void b5")
 
-
     def void_b3(b5, b3):
         b3.quantity = 0
         print("void b3")
 
     def transfer_b5_b3(b5, b3):
         transfer_amount = min(b5.quantity, b3.capacity - b3.quantity)
-        b5.quantity, b3.quantity = b5.quantity - transfer_amount, b3.quantity + transfer_amount
+        b5.quantity, b3.quantity = (
-    
+            b5.quantity - transfer_amount,
+            b3.quantity + transfer_amount,
+        )
 
     def transfer_b3_b5(b5, b3):
         transfer_amount = min(b3.quantity, b5.capacity - b5.quantity)
-        b5.quantity, b3.quantity = b5.quantity + transfer_amount, b3.quantity - transfer_amount
+        b5.quantity, b3.quantity = (
+            b5.quantity + transfer_amount,
+            b3.quantity - transfer_amount,
+        )

graphes/maze/maze_creator.py

@@ -1,5 +1,6 @@
 import random as rnd
 
+
 class Labyrinth:
     def __init__(self, rows, cols) -> None:
         self.rows = rows
@@ -50,7 +51,11 @@ class Labyrinth:
             # Trouver une cellule voisine qui est déjà un chemin
             for dx, dy in [(-2, 0), (2, 0), (0, -2), (0, 2)]:
                 cx, cy = nx + dx, ny + dy
-                if 0 <= cx < self.rows and 0 <= cy < self.cols and self.grid[cx][cy] == 0:
+                if (
+                    0 <= cx < self.rows
+                    and 0 <= cy < self.cols
+                    and self.grid[cx][cy] == 0
+                ):
                     # Casser le mur entre les deux cellules
                     self.casser_mur(cx, cy, nx, ny)
                     # Ajouter les nouveaux murs adjacents
@@ -68,5 +73,6 @@ class Labyrinth:
         """
         Représente le labyrinthe sous forme de chaîne de caractères.
         """
-        return "\n".join("".join(" " if cell == 0 else "#" for cell in row) for row in self.grid)
+        return "\n".join(
-
+            "".join(" " if cell == 0 else "#" for cell in row) for row in self.grid
+        )

graphes/maze/test.py

@@ -1,4 +1,6 @@
-from fifo import Pile  # Remplacez "fifo" par le nom exact de votre fichier contenant la classe Pile
+from fifo import (
+    Pile,
+)  # Remplacez "fifo" par le nom exact de votre fichier contenant la classe Pile
 
 # Initialisation
 pile = Pile()
@@ -13,7 +15,9 @@ assert pile.element == [5, 10], "Erreur : Les éléments de la pile ne correspon
 assert not pile.est_vide(), "Erreur : La pile ne devrait pas être vide"
 pile.defiler()
 pile.defiler()
-assert pile.est_vide(), "Erreur : La pile devrait être vide après avoir défiler tous les éléments"
+assert (
+    pile.est_vide()
+), "Erreur : La pile devrait être vide après avoir défiler tous les éléments"
 
 # Test de defiler
 pile.empiler(7)
@@ -48,4 +52,3 @@ except AssertionError as e:
     pass  # Test réussi
 
 print("Tous les tests sont passés avec succès !")
-

graphes/monday_homework.py

@@ -50,6 +50,7 @@ def construire_bfs(graphe: dict, origine: str) -> dict:
         couleur[courant] = 2
     return resultat
 
+
 def construire_dfs(graphe: dict, origine: str) -> dict:
     """
     Construit un arbre DFS à partir de graphe et d'un sommet d'origine.
@@ -102,7 +103,9 @@ def construire_dfs(graphe: dict, origine: str) -> dict:
         couleur[courant] = 2
     return resultat
 
+
 if __name__ == "__main__":
     import doctest
+
     doctest.testmod(verbose=True)
-    print(construire_dfs(g, '1'))
+    print(construire_dfs(g, "1"))

magic_square/TDliste2liste/exercice1.py

@@ -6,6 +6,7 @@ def appartient(elt,tableau):
             continue
     return False
 
+
 if __name__ == "__main__":
     print(appartient(5, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
     print(appartient(5, [1, 2, 3, 4, 6, 7, 8, 9, 10]))

magic_square/TDliste2liste/exercice2.py

@@ -7,6 +7,7 @@ def max_local(tableau):
             continue
     return maximum
 
+
 def indice_max(tableau):
     maximum = max_local(tableau)
     for i in range(len(tableau)):
@@ -15,6 +16,7 @@ def indice_max(tableau):
         else:
             continue
 
+
 if __name__ == "__main__":
     l1 = [0, 2, 3, 4, 5, 6, 7, 8, 9, 90, 91, 59, 1]
     print(max_local(l1))

magic_square/TDliste2liste/exercice3.py

@@ -1,8 +1,11 @@
 def cree_tableau_n_m(n, m):
     return [[0 for _ in range(m)] for _ in range(n)]
 
+
 def cree_tableau_carre_n(n):
     return [[0 for _ in range(n)] for _ in range(n)]
+
+
 if __name__ == "__main__":
     print(cree_tableau_n_m(3, 5))
     print(cree_tableau_carre_n(5))

magic_square/TDliste2liste/exercice4.py

@@ -8,5 +8,6 @@ def cree_carre_entier_1_n_carre(n):
             compteur += 1
         carre.append(ligne)
     return carre
-print(cree_carre_entier_1_n_carre(8))
 
+
+print(cree_carre_entier_1_n_carre(8))

magic_square/TDliste2liste/exercice5.py

@@ -2,8 +2,11 @@ def transpose(carre):
     n = len(carre)  # Nombre de lignes (ou colonnes, car c'est une matrice carrée)
     return [[carre[j][i] for j in range(n)] for i in range(n)]
 
+
 def transpose_en_place(carre):
     n = len(carre)  # Nombre de lignes (ou colonnes)
     for i in range(n):
-        for j in range(i + 1, n):  # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés
+        for j in range(
+            i + 1, n
+        ):  # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés
             carre[i][j], carre[j][i] = carre[j][i], carre[i][j]  # Échange des éléments

magic_square/TDliste2liste/exercice6.py

@@ -1,9 +1,11 @@
 def diag_1(carre):
     return [carre[i][i] for i in range(len(carre))]
 
+
 def diag_2(carre):
     n = len(carre)
     return [carre[i][n - 1 - i] for i in range(n)]
 
+
 def colonne(j, carre):
     return [carre[i][j] for i in range(len(carre))]

magic_square/magic_square.py

@@ -1,17 +1,24 @@
 from TDliste2liste.exercice6 import diag_1, diag_2, colonne
+
+
 def check_diagonale(liste):
     return diag1(liste), diag2(liste)
+
+
 def check_colonne(liste):
     somme = []
     for i in range(len(liste)):
         somme.append(colonne(i, liste))
     return somme
+
+
 def check_line(liste):
     somme = []
     for i in range(len(liste)):
         somme.append(sum(liste[i]))
     return somme
 
+
 def check_all(carre):
     diag1_values, diag2_values = check_diagonale(carre)
     colonne_values = check_colonne(carre)
@@ -42,7 +49,6 @@ def check_all(carre):
 
     return all_same
 
-carre1=[[4, 9, 2],\
+
-        [3, 5, 7],\
+carre1 = [[4, 9, 2], [3, 5, 7], [8, 1, 6]]
-        [8, 1, 6]]
 print(check_all(carre1))

magic_square/td_carre_magique.py

@@ -2,26 +2,9 @@
 # -*- coding: utf-8 -*-
 
 
-
+if __name__ == "__main__":
-
+    carre1 = [[4, 9, 2], [3, 5, 7], [8, 1, 6]]
-
+    carre2 = [[16, 9, 14], [11, 13, 15], [12, 17, 10]]
-
+    carre3 = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
-
+    carre4 = [[16, 3, 2, 13], [5, 10, 11, 8], [9, 6, 7, 12], [4, 15, 14, 1]]
-if __name__ == '__main__':
+    carre5 = [[1, 14, 14, 4], [11, 7, 6, 9], [8, 10, 10, 5], [13, 2, 3, 15]]
-	carre1=[[4, 9, 2],\
-	        [3, 5, 7],\
-	        [8, 1, 6]]
-	carre2=[[16, 9, 14],\
-	        [11, 13, 15],\
-	        [12, 17, 10]]
-	carre3=[[1, 2, 3],\
-	        [4, 5, 6],\
-	        [7, 8, 9]]
-	carre4=[[16, 3, 2, 13],\
-	        [5, 10, 11, 8],\
-	        [9, 6, 7, 12],\
-	        [4, 15, 14, 1]]
-	carre5=[[1, 14, 14, 4],\
-	        [11, 7, 6, 9],\
-	        [8, 10, 10, 5],\
-	        [13, 2, 3, 15]]

partition_fusion/code.py

@@ -8,6 +8,7 @@ def partition(tab, debut, fin):
     tab[i + 1], tab[fin] = tab[fin], tab[i + 1]
     return i + 1
 
+
 def fusion(tab, debut, milieu, fin):
     gauche = tab[debut : milieu + 1]
     droite = tab[milieu + 1 : fin + 1]
@@ -32,6 +33,7 @@ def fusion(tab, debut, milieu, fin):
         j += 1
         k += 1
 
+
 def tri_fusion_partition(tab, debut, fin):
     if debut < fin:
         pivot_index = partition(tab, debut, fin)
@@ -39,7 +41,7 @@ def tri_fusion_partition(tab, debut, fin):
         tri_fusion_partition(tab, pivot_index + 1, fin)
         fusion(tab, debut, pivot_index, fin)
 
+
 tableau = [34, 7, 23, 32, 5, 62, 32, 8, 9]
 tri_fusion_partition(tableau, 0, len(tableau) - 1)
 print("Tableau trié :", tableau)
-

partition_fusion/code2.py

@@ -1,5 +1,8 @@
 from random import shuffle
+
 i = 0
+
+
 def fusion(liste_1, liste_2):
     global i
     if len(liste_1) == 0:
@@ -12,6 +15,7 @@ def fusion(liste_1,liste_2):
     i += 1
     return [liste_2[0]] + fusion(liste_1, liste_2[1:])
 
+
 def tri_pf(liste):
     global i
     if len(liste) <= 1:
@@ -21,7 +25,6 @@ def tri_pf(liste):
     return fusion(tri_pf(liste[:millieu]), tri_pf(liste[millieu:]))
 
 
-
 test = [23, 8, 20, 10, 13, 1]
 print(test, i)
 test = tri_pf(test)

partition_fusion/liste.py

@@ -7,22 +7,24 @@ Created on Mon Feb 10 09:15:57 2025
 """
 
 
-
-
 def creer_liste():
     return ()
 
+
 def est_vide(liste):
     return len(liste) == 0
 
+
 def ajouter(liste, element):
     return (element, liste)
 
+
 def tete(liste):
     assert not (est_vide(liste)), "Liste vide"
     element, _ = liste
     return element
 
+
 def queue(liste):
     assert not (est_vide(liste)), "Liste vide"
     _, reste = liste

partition_fusion/partition_fusion.py

@@ -17,13 +17,13 @@ def taille(liste):
         a += 1
     return a
 
+
 def divise2(liste):
     n = taille(liste)
     droite, gauche = partition(liste, 0, n // 2)
     return droite, gauche
 
 
-
 def renverser(liste):
     result = fifo.creer_liste()
     while not fifo.est_vide(liste):
@@ -66,7 +66,6 @@ def fusion(gauche,droite):
         return fifo.ajouter(fusion(gauche, fifo.queue(droite)), fifo.tete(droite))
 
 
-
 def merge_sort(liste):
 
     if fifo.est_vide(liste):
@@ -75,12 +74,12 @@ def merge_sort(liste):
         return liste  # si elle ne contient que un elt
     gauche, droite = divise2(liste)
 
-
     tri1 = merge_sort(gauche)  # recursif
     tri2 = merge_sort(droite)  # recursif
 
     return fusion(tri1, tri2)
 
+
 if __name__ == "__main__":
     liste = fifo.creer_liste()
     for i in reversed(range(100)):

perfect_number/main.py

@@ -1,4 +1,6 @@
 import math
+
+
 def find_diviseur(number):
     diviseurs = []
     limit = int(number / 2)
@@ -7,5 +9,6 @@ def find_diviseur(number):
             diviseurs.append(i)
     return diviseurs
 
+
 if __name__ == "__main__":
     print(find_diviseur(15))

pygame/V2/balle/balle.py

@@ -3,6 +3,7 @@ from constantes import *
 import raquette
 from math import *
 
+
 class Balle(object):
 
     def __init__(self):
@@ -12,15 +13,15 @@ class Balle(object):
         self.xvit = 4.5
         self.yvit = 3.0
 
-        
     def deplace(self, raquette):
         self.xpos += self.xvit
         self.ypos += self.yvit
         self.rebonds(raquette)
 
-        
     def affiche(self, ecran):
-        pygame.draw.circle(ecran,(0,0,0) , (int(self.xpos),int(self.ypos)) , self.rayon)
+        pygame.draw.circle(
+            ecran, (0, 0, 0), (int(self.xpos), int(self.ypos)), self.rayon
+        )
 
     def rebonds(self, raquette):
         if self.xpos + self.rayon > LARGEUR_ECRAN or self.xpos - self.rayon < 0:
@@ -32,7 +33,10 @@ class Balle(object):
             if self.xpos >= raquette.xpos:
                 if self.xpos <= raquette.xpos + raquette.largeur:
                     self.yvit = -self.yvit
-                    if self.xpos >= raquette.xpos + raquette.largeur - raquette.largeur/10:
+                    if (
+                        self.xpos
+                        >= raquette.xpos + raquette.largeur - raquette.largeur / 10
+                    ):
                         self.xvit = 4.0
                         self.yvit = 6.0
 

pygame/V2/balle/balle_rebondissante.py

@@ -8,7 +8,7 @@ pygame.init()	#initialisation des modules de pygame
 ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
 ecran.fill(BLANC)
 
-pygame.display.set_caption('Balle rebondissante')
+pygame.display.set_caption("Balle rebondissante")
 
 clock = pygame.time.Clock()
 
@@ -30,7 +30,6 @@ while True:		#Demarrage de la boucle infinie
     b1.affiche(ecran)
     pygame.display.update()
 
-			
     ecran.fill(BLANC)
     if bouge:
         b1.deplace()
@@ -39,5 +38,5 @@ while True:		#Demarrage de la boucle infinie
     pygame.display.update()  # rafraichissement
     clock.tick(60)
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     b1 = balle.Balle()

pygame/V2/balle/casse_brique.py

@@ -9,7 +9,7 @@ pygame.init()
 ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
 
 # Titre de la fenetre
-pygame.display.set_caption('Casse_Brique')
+pygame.display.set_caption("Casse_Brique")
 
 clock = pygame.time.Clock()
 
@@ -36,8 +36,6 @@ while True :
     if bouge:
         b1.deplace(r1)
 
-        
-     
     b1.deplace(r1)
     b1.affiche(ecran)
     r1.affiche(ecran)

pygame/V2/balle/raquette.py

@@ -1,6 +1,7 @@
 import pygame
 from constantes import *
 
+
 class Raquette:
     """
     Definie une raquette qui se deplace horizontalement
@@ -32,7 +33,6 @@ class Raquette:
         if self.xpos < 0:
             self.xpos = 0
 
-
     def deplaceDroite(self):
         """
         Deplace la raquette de vit vers la droite
@@ -50,7 +50,10 @@ class Raquette:
             self.xpos = LARGEUR_ECRAN - self.largeur
 
     def affiche(self, ecran):
-        pygame.draw.rect(ecran, (0,0,255), (int(self.xpos), HAUTEUR_ECRAN-20, self.largeur, 10))
+        pygame.draw.rect(
+            ecran, (0, 0, 255), (int(self.xpos), HAUTEUR_ECRAN - 20, self.largeur, 10)
+        )
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     pass

pygame/bouncing_ball/ball.py

@@ -1,5 +1,6 @@
 import sys, pygame
 import balle
+
 ##########Definitions des constantes
 # Taille de la fenetre
 LARGEUR_ECRAN = 600
@@ -14,7 +15,7 @@ pygame.init()	#initialisation des modules de pygame
 ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
 ecran.fill(BLANC)
 
-pygame.display.set_caption('Balle rebondissante')
+pygame.display.set_caption("Balle rebondissante")
 
 clock = pygame.time.Clock()
 
@@ -31,7 +32,6 @@ while True:		#Demarrage de la boucle infinie
         elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
             bouge = not bouge
 
-			
     ecran.fill(BLANC)
     if bouge:
         b1.deplace()
@@ -39,4 +39,3 @@ while True:		#Demarrage de la boucle infinie
 
     pygame.display.update()  # rafraichissement
     clock.tick(60)
-

pygame/bouncing_ball/balle.py

@@ -1,5 +1,6 @@
 import pygame
 
+
 class Balle:
     """
     Definie une balle qui se deplace dans la fenetre ecran

pygame/bouncing_ball/constantes.py

@@ -2,4 +2,3 @@ LARGEUR_ECRAN = 600
 HAUTEUR_ECRAN = 800
 
 BLANC = (255, 255, 255)
-

pygame/bouncing_ball/raquette.py

@@ -9,7 +9,7 @@ pygame.init()
 # Création de la fenêtre
 ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
 ecran.fill(BLANC)
-pygame.display.set_caption('Balle rebondissante avec raquette')
+pygame.display.set_caption("Balle rebondissante avec raquette")
 
 clock = pygame.time.Clock()
 
@@ -37,8 +37,10 @@ while True:  # Boucle principale
         balle.deplace()
 
     # Collision balle-raquette
-    if (balle.ypos + balle.rayon >= HAUTEUR_ECRAN - 20 and
+    if (
-            raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur):
+        balle.ypos + balle.rayon >= HAUTEUR_ECRAN - 20
+        and raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur
+    ):
         balle.yvit = -balle.yvit
 
     balle.affiche(ecran)
@@ -46,4 +48,3 @@ while True:  # Boucle principale
 
     pygame.display.update()
     clock.tick(60)
-

pygame/bouncing_ball_project/ball.py

@@ -1,5 +1,6 @@
 import sys, pygame
 import balle
+
 ##########Definitions des constantes
 # Taille de la fenetre
 LARGEUR_ECRAN = 600
@@ -14,7 +15,7 @@ pygame.init()	#initialisation des modules de pygame
 ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
 ecran.fill(BLANC)
 
-pygame.display.set_caption('Balle rebondissante')
+pygame.display.set_caption("Balle rebondissante")
 
 clock = pygame.time.Clock()
 
@@ -31,7 +32,6 @@ while True:		#Demarrage de la boucle infinie
         elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
             bouge = not bouge
 
-			
     ecran.fill(BLANC)
     if bouge:
         b1.deplace()
@@ -39,4 +39,3 @@ while True:		#Demarrage de la boucle infinie
 
     pygame.display.update()  # rafraichissement
     clock.tick(60)
-

pygame/bouncing_ball_project/balle.py

@@ -1,6 +1,7 @@
 import pygame
 import pygame
 
+
 class Balle:
     """
     Definie une balle qui se deplace dans la fenetre ecran
@@ -29,4 +30,6 @@ class Balle:
         Paramètres :
             ecran : pygame.Surface - L'écran où dessiner la balle
         """
-        pygame.draw.circle(ecran, (255, 0, 0), (int(self.xpos), int(self.ypos)), self.rayon)
+        pygame.draw.circle(
+            ecran, (255, 0, 0), (int(self.xpos), int(self.ypos)), self.rayon
+        )

pygame/bouncing_ball_project/bouncing_ball_game.py

@@ -9,7 +9,7 @@ pygame.init()
 # Création de la fenêtre
 ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
 ecran.fill(BLANC)
-pygame.display.set_caption('Balle rebondissante avec raquette')
+pygame.display.set_caption("Balle rebondissante avec raquette")
 
 clock = pygame.time.Clock()
 
@@ -37,8 +37,10 @@ while True:  # Boucle principale
         balle.deplace()
 
     # Collision balle-raquette
-    if (balle.ypos + balle.rayon >= HAUTEUR_ECRAN - 20 and
+    if (
-            raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur):
+        balle.ypos + balle.rayon >= HAUTEUR_ECRAN - 20
+        and raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur
+    ):
         balle.yvit = -balle.yvit
 
     balle.affiche(ecran)

pygame/bouncing_ball_project/constantes.py

@@ -2,4 +2,3 @@ LARGEUR_ECRAN = 600
 HAUTEUR_ECRAN = 800
 
 BLANC = (255, 255, 255)
-

pygame/bouncing_ball_project/raquette.py

@@ -1,6 +1,7 @@
 import pygame
 from constantes import *
 
+
 class Raquette:
     """
     Définit une raquette qui se déplace horizontalement
@@ -33,7 +34,10 @@ class Raquette:
         """
         Dessine la raquette sur l'écran.
         """
-        pygame.draw.rect(ecran, (0, 0, 255), (int(self.xpos), HAUTEUR_ECRAN - 20, self.largeur, 10))
+        pygame.draw.rect(
+            ecran, (0, 0, 255), (int(self.xpos), HAUTEUR_ECRAN - 20, self.largeur, 10)
+        )
 
-if __name__ == '__main__':
+
+if __name__ == "__main__":
     pass

pygame/lab_py/main.py

@@ -15,12 +15,13 @@ WHITE = (255, 255, 255)
 GRAY = (100, 100, 100)
 GREEN = (0, 255, 0)
 
+
 class Cell:
     def __init__(self, i, j):
         self.i = i  # Numéro de la colonne
         self.j = j  # Numéro de la ligne
         # Chaque cellule possède 4 murs, tous présents initialement
-        self.walls = {'top': True, 'right': True, 'bottom': True, 'left': True}
+        self.walls = {"top": True, "right": True, "bottom": True, "left": True}
         self.visited = False
 
     def draw(self, surface):
@@ -33,21 +34,27 @@ class Cell:
             pygame.draw.rect(surface, GRAY, (x, y, CELL_SIZE, CELL_SIZE))
 
         # Dessiner les murs par-dessus la couleur de fond
-        if self.walls['top']:
+        if self.walls["top"]:
             pygame.draw.line(surface, WHITE, (x, y), (x + CELL_SIZE, y))
-        if self.walls['right']:
+        if self.walls["right"]:
-            pygame.draw.line(surface, WHITE, (x + CELL_SIZE, y), (x + CELL_SIZE, y + CELL_SIZE))
+            pygame.draw.line(
-        if self.walls['bottom']:
+                surface, WHITE, (x + CELL_SIZE, y), (x + CELL_SIZE, y + CELL_SIZE)
-            pygame.draw.line(surface, WHITE, (x + CELL_SIZE, y + CELL_SIZE), (x, y + CELL_SIZE))
+            )
-        if self.walls['left']:
+        if self.walls["bottom"]:
+            pygame.draw.line(
+                surface, WHITE, (x + CELL_SIZE, y + CELL_SIZE), (x, y + CELL_SIZE)
+            )
+        if self.walls["left"]:
             pygame.draw.line(surface, WHITE, (x, y + CELL_SIZE), (x, y))
 
+
 def get_cell(i, j):
     """Retourne la cellule aux coordonnées (i, j) si elle existe."""
     if 0 <= i < COLS and 0 <= j < ROWS:
         return grid[i][j]
     return None
 
+
 def get_unvisited_neighbors(cell):
     """Retourne la liste des voisins non visités de la cellule donnée."""
     neighbors = []
@@ -71,6 +78,7 @@ def get_unvisited_neighbors(cell):
 
     return neighbors
 
+
 def remove_walls(current, next_cell):
     """
     Enlève les murs entre la cellule courante et le voisin sélectionné.
@@ -78,17 +86,18 @@ def remove_walls(current, next_cell):
     dx = next_cell.i - current.i
     dy = next_cell.j - current.j
     if dx == 1:  # Voisin à droite
-        current.walls['right'] = False
+        current.walls["right"] = False
-        next_cell.walls['left'] = False
+        next_cell.walls["left"] = False
     elif dx == -1:  # Voisin à gauche
-        current.walls['left'] = False
+        current.walls["left"] = False
-        next_cell.walls['right'] = False
+        next_cell.walls["right"] = False
     elif dy == 1:  # Voisin en bas
-        current.walls['bottom'] = False
+        current.walls["bottom"] = False
-        next_cell.walls['top'] = False
+        next_cell.walls["top"] = False
     elif dy == -1:  # Voisin en haut
-        current.walls['top'] = False
+        current.walls["top"] = False
-        next_cell.walls['bottom'] = False
+        next_cell.walls["bottom"] = False
+
 
 def main():
     global grid
@@ -149,6 +158,6 @@ def main():
     pygame.quit()
     sys.exit()
 
-if __name__ == '__main__':
-    main()
 
+if __name__ == "__main__":
+    main()

recursivite/TD1.py

@@ -4,6 +4,7 @@ def factorielle(number: int):
     else:
         return number * factorielle(number - 1)
 
+
 def modulo(a, b):
     if b - a < 0:
         return b
@@ -11,18 +12,25 @@ def modulo(a, b):
         return b
     else:
         return modulo(a, b - a)
+
+
 def somme(n):
     if n == 0:
         return n
     else:
-        return(n+somme(n-1))
+        return n + somme(n - 1)
+
+
 def init_quotient(a, b):
     i = 0
-    return (quotient(a,b,i))
+    return quotient(a, b, i)
+
+
 def quotient(a, b, i):
     if b == 0 or b - a < 0:
         return i
     else:
-        return(quotient(a,b-a,i+1))
+        return quotient(a, b - a, i + 1)
+
 
 print(init_quotient(6, 18))

recursivite/exercice_MJoannic/dichotomie/iteratif/main.py

@@ -1,5 +1,6 @@
 from sort_list import sort_list
 
+
 def dichotomie(liste: list, element: any, bypass_sorting=False) -> bool:
     """This function return return True if element is in liste False else
 
@@ -12,7 +13,9 @@ def dichotomie(liste: list, element: any,bypass_sorting = False)->bool:
     """
     if liste == []:
         return False
-    assert type(element) == type(liste[0]), "Wrong type between liste and element" # On estime que la liste contient un seul et unique type...
+    assert type(element) == type(
+        liste[0]
+    ), "Wrong type between liste and element"  # On estime que la liste contient un seul et unique type...
     if bypass_sorting == False:
         liste = sort_list(liste)
     N, start, find, i = len(liste) - 1, 0, False, 0

recursivite/exercice_MJoannic/dichotomie/iteratif/tester.py

@@ -1,4 +1,6 @@
 from main import dichotomie
+
+
 def tester():
     liste1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     liste2 = liste1[:-1]
@@ -8,49 +10,75 @@ def tester():
     liste5 = [1]
     liste6 = [1.0, 2.0, 3.1, 4.2, 8.6, 8.3]
     liste7 = [-1, -2, -2, -3, -4]
-    liste8 = list("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.")
+    liste8 = list(
+        "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+    )
     liste9 = [i for i in range(1, 100000)]
     assert dichotomie(liste1, 5) == True, "Test échoué : 5 devrait être dans liste1"
-    assert dichotomie(liste1, 11) == False, "Test échoué : 11 ne devrait pas être dans liste1"
+    assert (
+        dichotomie(liste1, 11) == False
+    ), "Test échoué : 11 ne devrait pas être dans liste1"
 
     # Tests pour liste2
     assert dichotomie(liste2, 9) == True, "Test échoué : 9 devrait être dans liste2"
-    assert dichotomie(liste2, 10) == False, "Test échoué : 10 ne devrait pas être dans liste2"
+    assert (
+        dichotomie(liste2, 10) == False
+    ), "Test échoué : 10 ne devrait pas être dans liste2"
 
     # Tests pour liste3
     assert dichotomie(liste3, 8) == True, "Test échoué : 8 devrait être dans liste3"
-    assert dichotomie(liste3, 11) == False, "Test échoué : 11 ne devrait pas être dans liste3"
+    assert (
+        dichotomie(liste3, 11) == False
+    ), "Test échoué : 11 ne devrait pas être dans liste3"
 
     # Tests pour liste3_2
     assert dichotomie(liste3_2, 7) == True, "Test échoué : 7 devrait être dans liste3_2"
-    assert dichotomie(liste3_2, 10) == False, "Test échoué : 10 ne devrait pas être dans liste3_2"
+    assert (
+        dichotomie(liste3_2, 10) == False
+    ), "Test échoué : 10 ne devrait pas être dans liste3_2"
 
     # Tests pour liste4
-    assert dichotomie(liste4, 1) == False, "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
+    assert (
-    assert dichotomie(liste4, 0) == False, "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
+        dichotomie(liste4, 1) == False
+    ), "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
+    assert (
+        dichotomie(liste4, 0) == False
+    ), "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
 
     # Tests pour liste5
     assert dichotomie(liste5, 1) == True, "Test échoué : 1 devrait être dans liste5"
-    assert dichotomie(liste5, 2) == False, "Test échoué : 2 ne devrait pas être dans liste5"
+    assert (
+        dichotomie(liste5, 2) == False
+    ), "Test échoué : 2 ne devrait pas être dans liste5"
 
     # Tests pour liste6
     assert dichotomie(liste6, 3.1) == True, "Test échoué : 3.1 devrait être dans liste6"
-    assert dichotomie(liste6, 5.5) == False, "Test échoué : 5.5 ne devrait pas être dans liste6"
+    assert (
+        dichotomie(liste6, 5.5) == False
+    ), "Test échoué : 5.5 ne devrait pas être dans liste6"
 
     # Tests pour liste7
     assert dichotomie(liste7, -3) == True, "Test échoué : -3 devrait être dans liste7"
-    assert dichotomie(liste7, 0) == False, "Test échoué : 0 ne devrait pas être dans liste7"
+    assert (
+        dichotomie(liste7, 0) == False
+    ), "Test échoué : 0 ne devrait pas être dans liste7"
 
     # Tests pour liste8
     assert dichotomie(liste8, "L") == True, "Test échoué : 'L' devrait être dans liste8"
-    assert dichotomie(liste8, "Z") == False, "Test échoué : 'Z' ne devrait pas être dans liste8"
+    assert (
+        dichotomie(liste8, "Z") == False
+    ), "Test échoué : 'Z' ne devrait pas être dans liste8"
 
     # Tests pour liste9
-    assert dichotomie(liste9, 99999, True) == True, "Test échoué : 99999 devrait être dans liste9" # bypass = True because sorting_list is very slow
+    assert (
-    assert dichotomie(liste9, 0,True) == False, "Test échoué : 5 ne devrait pas être dans liste9"# bypass = True because sorting_list is very slow
+        dichotomie(liste9, 99999, True) == True
+    ), "Test échoué : 99999 devrait être dans liste9"  # bypass = True because sorting_list is very slow
+    assert (
+        dichotomie(liste9, 0, True) == False
+    ), "Test échoué : 5 ne devrait pas être dans liste9"  # bypass = True because sorting_list is very slow
 
     print("Tous les tests ont réussi !")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     tester()

recursivite/exercice_MJoannic/dichotomie/recursif/correction/V1.py

@@ -10,8 +10,10 @@ def est_triee(liste: list)->bool:
         index += 1
     return index >= len(liste) - 1
 
+
 def search(liste: list, element: Any):
     assert est_triee(liste), "Pas de recherche sur une liste non triee"
+
     def aux(liste, element):
         if len(liste) == 0:
             return True
@@ -22,6 +24,7 @@ def search(liste:list, element:Any):
             if element < pivot:
                 return aux(liste[len(liste) // 2], element)
             return aux(liste[len(liste) // 3 + 1 :], element)
+
     return aux(liste, element)
 
 

recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/main.py

@@ -1,7 +1,14 @@
 from sort_list import sort_list
 from typing import Any
 
-def dichotomie(liste: list[Any], element: Any, start: int = 0, end: int = None, bypass_sorting: bool = False) -> int:
+
+def dichotomie(
+    liste: list[Any],
+    element: Any,
+    start: int = 0,
+    end: int = None,
+    bypass_sorting: bool = False,
+) -> int:
     """Performs a dichotomy search to determine if an element exists in a list or not.
 
     Args:
@@ -32,6 +39,10 @@ def dichotomie(liste: list[Any], element: Any, start: int = 0, end: int = None,
     if liste[middle] == element:
         return middle
     elif element < liste[middle]:
-        return dichotomie(liste, element, start, middle - 1, bypass_sorting=True) # bypass_sorting because it's already done
+        return dichotomie(
+            liste, element, start, middle - 1, bypass_sorting=True
+        )  # bypass_sorting because it's already done
     else:
-        return dichotomie(liste, element, middle + 1, end, bypass_sorting=True) # bypass_sorting because it's already done
+        return dichotomie(
+            liste, element, middle + 1, end, bypass_sorting=True
+        )  # bypass_sorting because it's already done

recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/tester.py

@@ -1,5 +1,6 @@
 from main import dichotomie
 
+
 def tester():
     liste1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     liste2 = liste1[:-1]
@@ -9,72 +10,108 @@ def tester():
     liste5 = [1]
     liste6 = [1.0, 2.0, 3.1, 4.2, 8.6, 8.3]
     liste7 = [-1, -2, -2, -3, -4]
-    liste8 = list("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.")
+    liste8 = list(
+        "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+    )
     liste9 = [i for i in range(1, 100000)]
 
     # Tests pour liste1
-    assert dichotomie(liste1, 5) == 4, "Test échoué : 5 devrait être à l'index 4 dans liste1"
+    assert (
+        dichotomie(liste1, 5) == 4
+    ), "Test échoué : 5 devrait être à l'index 4 dans liste1"
     print("Test n°1 réussi")
-    assert dichotomie(liste1, 11) == -1, "Test échoué : 11 ne devrait pas être dans liste1"
+    assert (
+        dichotomie(liste1, 11) == -1
+    ), "Test échoué : 11 ne devrait pas être dans liste1"
     print("Test n°2 réussi")
 
     # Tests pour liste2
-    assert dichotomie(liste2, 9) == 8, "Test échoué : 9 devrait être à l'index 8 dans liste2"
+    assert (
+        dichotomie(liste2, 9) == 8
+    ), "Test échoué : 9 devrait être à l'index 8 dans liste2"
     print("Test n°3 réussi")
-    assert dichotomie(liste2, 10) == -1, "Test échoué : 10 ne devrait pas être dans liste2"
+    assert (
+        dichotomie(liste2, 10) == -1
+    ), "Test échoué : 10 ne devrait pas être dans liste2"
     print("Test n°4 réussi")
-    '''
+    """
     # Tests pour liste3 (tri nécessaire)
     assert dichotomie(liste3, 8) == 7, "Test échoué : 8 devrait être à l'index 7 après tri dans liste3"
     print("Test n°5 réussi")
     assert dichotomie(liste3, 11) == -1, "Test échoué : 11 ne devrait pas être dans liste3"
     print("Test n°6 réussi")
-    '''
+    """
     # Tests pour liste3_2
     assert dichotomie(liste3_2, 7) == 3, "Test échoué : 7 devrait être dans liste3_2"
     print("Test n°7 réussi")
-    assert dichotomie(liste3_2, 10) == -1, "Test échoué : 10 ne devrait pas être dans liste3_2"
+    assert (
+        dichotomie(liste3_2, 10) == -1
+    ), "Test échoué : 10 ne devrait pas être dans liste3_2"
     print("Test n°8 réussi")
 
     # Tests pour liste4
     print(dichotomie(liste4, 1))
-    assert dichotomie(liste4, 1) == -1, "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
+    assert (
+        dichotomie(liste4, 1) == -1
+    ), "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
     print("Test n°9 réussi")
-    assert dichotomie(liste4, 0) == -1, "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
+    assert (
+        dichotomie(liste4, 0) == -1
+    ), "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
     print("Test n°10 réussi")
 
     # Tests pour liste5
-    assert dichotomie(liste5, 1) == 0, "Test échoué : 1 devrait être à l'index 0 dans liste5"
+    assert (
+        dichotomie(liste5, 1) == 0
+    ), "Test échoué : 1 devrait être à l'index 0 dans liste5"
     print("Test n°11 réussi")
-    assert dichotomie(liste5, 2) == -1, "Test échoué : 2 ne devrait pas être dans liste5"
+    assert (
+        dichotomie(liste5, 2) == -1
+    ), "Test échoué : 2 ne devrait pas être dans liste5"
     print("Test n°12 réussi")
 
     # Tests pour liste6
-    assert dichotomie(liste6, 3.1) == 2, "Test échoué : 3.1 devrait être à l'index 2 dans liste6"
+    assert (
+        dichotomie(liste6, 3.1) == 2
+    ), "Test échoué : 3.1 devrait être à l'index 2 dans liste6"
     print("Test n°13 réussi")
-    assert dichotomie(liste6, 5.5) == -1, "Test échoué : 5.5 ne devrait pas être dans liste6"
+    assert (
+        dichotomie(liste6, 5.5) == -1
+    ), "Test échoué : 5.5 ne devrait pas être dans liste6"
     print("Test n°14 réussi")
 
     # Tests pour liste7 (tri nécessaire)
-    assert dichotomie(liste7, -3) == 1, "Test échoué : -3 devrait être à l'index 1 après tri dans liste7"
+    assert (
+        dichotomie(liste7, -3) == 1
+    ), "Test échoué : -3 devrait être à l'index 1 après tri dans liste7"
     print("Test n°15 réussi")
-    assert dichotomie(liste7, 0) == -1, "Test échoué : 0 ne devrait pas être dans liste7"
+    assert (
+        dichotomie(liste7, 0) == -1
+    ), "Test échoué : 0 ne devrait pas être dans liste7"
     print("Test n°16 réussi")
 
     # Tests pour liste8
-    assert dichotomie(liste8, "A") == 0, "Test échoué : 'L' devrait être à l'index 0 dans liste8"
+    assert (
+        dichotomie(liste8, "A") == 0
+    ), "Test échoué : 'L' devrait être à l'index 0 dans liste8"
     print("Test n°17 réussi")
-    assert dichotomie(liste8, "Z") == -1, "Test échoué : 'Z' ne devrait pas être dans liste8"
+    assert (
+        dichotomie(liste8, "Z") == -1
+    ), "Test échoué : 'Z' ne devrait pas être dans liste8"
     print("Test n°18 réussi")
 
     # Tests pour liste9 (tri déjà fait)
-    assert dichotomie(liste9, 99999, bypass_sorting=True) == 99998, "Test échoué : 99999 devrait être à l'index 99998 dans liste9"
+    assert (
+        dichotomie(liste9, 99999, bypass_sorting=True) == 99998
+    ), "Test échoué : 99999 devrait être à l'index 99998 dans liste9"
     print("Test n°19 réussi")
-    assert dichotomie(liste9, 0, bypass_sorting=True) == -1, "Test échoué : 0 ne devrait pas être dans liste9"
+    assert (
+        dichotomie(liste9, 0, bypass_sorting=True) == -1
+    ), "Test échoué : 0 ne devrait pas être dans liste9"
     print("Test n°20 réussi")
 
     print("Tous les tests ont réussi !")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     tester()

recursivite/exercice_MJoannic/dichotomie/recursif/myself/main.py

@@ -1,7 +1,14 @@
 from sort_list import sort_list
 from typing import Any
 
-def dichotomie(liste: list[Any], element: Any, start: int = 0, end: int = None, bypass_sorting: bool = False) -> bool:
+
+def dichotomie(
+    liste: list[Any],
+    element: Any,
+    start: int = 0,
+    end: int = None,
+    bypass_sorting: bool = False,
+) -> bool:
     """Performs a dichotomy search to determine if an element exists in a list or not.
 
     Args:
@@ -33,6 +40,10 @@ def dichotomie(liste: list[Any], element: Any, start: int = 0, end: int = None,
     if liste[middle] == element:
         return True
     elif element < liste[middle]:
-        return dichotomie(liste, element, start, middle - 1, bypass_sorting=True) # bypass_sorting because it's already done
+        return dichotomie(
+            liste, element, start, middle - 1, bypass_sorting=True
+        )  # bypass_sorting because it's already done
     else:
-        return dichotomie(liste, element, middle + 1, end, bypass_sorting=True) # bypass_sorting because it's already done
+        return dichotomie(
+            liste, element, middle + 1, end, bypass_sorting=True
+        )  # bypass_sorting because it's already done

recursivite/exercice_MJoannic/dichotomie/recursif/myself/tester.py

@@ -1,4 +1,6 @@
 from main import dichotomie
+
+
 def tester():
     liste1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
     liste2 = liste1[:-1]
@@ -8,71 +10,97 @@ def tester():
     liste5 = [1]
     liste6 = [1.0, 2.0, 3.1, 4.2, 8.6, 8.3]
     liste7 = [-1, -2, -2, -3, -4]
-    liste8 = list("Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.")
+    liste8 = list(
+        "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum."
+    )
     liste9 = [i for i in range(1, 100000)]
 
     # Tests pour liste1
     assert dichotomie(liste1, 5) == True, "Test échoué : 5 devrait être dans liste1"
     print("Test n°1 done")
-    assert dichotomie(liste1, 11) == False, "Test échoué : 11 ne devrait pas être dans liste1"
+    assert (
+        dichotomie(liste1, 11) == False
+    ), "Test échoué : 11 ne devrait pas être dans liste1"
     print("Test n°2 done")
 
     # Tests pour liste2
     assert dichotomie(liste2, 9) == True, "Test échoué : 9 devrait être dans liste2"
     print("Test n°3 done")
-    assert dichotomie(liste2, 10) == False, "Test échoué : 10 ne devrait pas être dans liste2"
+    assert (
+        dichotomie(liste2, 10) == False
+    ), "Test échoué : 10 ne devrait pas être dans liste2"
     print("Test n°4 done")
 
     # Tests pour liste3
     assert dichotomie(liste3, 8) == True, "Test échoué : 8 devrait être dans liste3"
     print("Test n°5 done")
-    assert dichotomie(liste3, 11) == False, "Test échoué : 11 ne devrait pas être dans liste3"
+    assert (
+        dichotomie(liste3, 11) == False
+    ), "Test échoué : 11 ne devrait pas être dans liste3"
     print("Test n°6 done")
 
     # Tests pour liste3_2
     assert dichotomie(liste3_2, 7) == True, "Test échoué : 7 devrait être dans liste3_2"
     print("Test n°7 done")
-    assert dichotomie(liste3_2, 10) == False, "Test échoué : 10 ne devrait pas être dans liste3_2"
+    assert (
+        dichotomie(liste3_2, 10) == False
+    ), "Test échoué : 10 ne devrait pas être dans liste3_2"
     print("Test n°8 done")
 
     # Tests pour liste4
-    assert dichotomie(liste4, 1) == False, "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
+    assert (
+        dichotomie(liste4, 1) == False
+    ), "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
     print("Test n°9 done")
-    assert dichotomie(liste4, 0) == False, "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
+    assert (
+        dichotomie(liste4, 0) == False
+    ), "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
     print("Test n°10 done")
 
     # Tests pour liste5
     assert dichotomie(liste5, 1) == True, "Test échoué : 1 devrait être dans liste5"
     print("Test n°11 done")
-    assert dichotomie(liste5, 2) == False, "Test échoué : 2 ne devrait pas être dans liste5"
+    assert (
+        dichotomie(liste5, 2) == False
+    ), "Test échoué : 2 ne devrait pas être dans liste5"
     print("Test n°12 done")
 
     # Tests pour liste6
     assert dichotomie(liste6, 3.1) == True, "Test échoué : 3.1 devrait être dans liste6"
     print("Test n°13 done")
-    assert dichotomie(liste6, 5.5) == False, "Test échoué : 5.5 ne devrait pas être dans liste6"
+    assert (
+        dichotomie(liste6, 5.5) == False
+    ), "Test échoué : 5.5 ne devrait pas être dans liste6"
     print("Test n°14 done")
 
     # Tests pour liste7
     assert dichotomie(liste7, -3) == True, "Test échoué : -3 devrait être dans liste7"
     print("Test n°15 done")
-    assert dichotomie(liste7, 0) == False, "Test échoué : 0 ne devrait pas être dans liste7"
+    assert (
+        dichotomie(liste7, 0) == False
+    ), "Test échoué : 0 ne devrait pas être dans liste7"
     print("Test n°16 done")
 
     # Tests pour liste8
     assert dichotomie(liste8, "L") == True, "Test échoué : 'L' devrait être dans liste8"
     print("Test n°17 done")
-    assert dichotomie(liste8, "Z") == False, "Test échoué : 'Z' ne devrait pas être dans liste8"
+    assert (
+        dichotomie(liste8, "Z") == False
+    ), "Test échoué : 'Z' ne devrait pas être dans liste8"
     print("Test n°18 done")
 
     # Tests pour liste9
-    assert dichotomie(liste9, 99999, bypass_sorting=True) == True, "Test échoué : 99999 devrait être dans liste9"
+    assert (
+        dichotomie(liste9, 99999, bypass_sorting=True) == True
+    ), "Test échoué : 99999 devrait être dans liste9"
     print("Test n°19 done")
-    assert dichotomie(liste9, 0, bypass_sorting=True) == False, "Test échoué : 0 ne devrait pas être dans liste9"
+    assert (
+        dichotomie(liste9, 0, bypass_sorting=True) == False
+    ), "Test échoué : 0 ne devrait pas être dans liste9"
     print("Test n°20 done")
 
     print("Tous les tests ont reussi !")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     tester()

recursivite/exercice_MJoannic/palindrom.py

@@ -9,4 +9,5 @@ def is_palindrom(word)->bool:
     else:
         return False
 
-print(is_palindrom("do geese see god".replace(' ', '')))
+
+print(is_palindrom("do geese see god".replace(" ", "")))

recursivite/exercice_MJoannic/sqrt/correction/main.py

@@ -1,7 +1,6 @@
 def racine(n):
     def aux(gauche, droite):
 
-
         if gauche > droite:
             return droite
 
@@ -15,8 +14,8 @@ def racine(n):
 
         else:
             return aux(milieu + 1, droite)
-    return aux(0, n)
 
+    return aux(0, n)
 
 
 def racine_decimale(n, precision=1e-6):

recursivite/exercice_MJoannic/sqrt/main.py

@@ -12,11 +12,18 @@ def racine_raphson(number: float, precision: float) -> float:
 
     return y
 
+
 if __name__ == "__main__":
     print(racine_raphson(36, 0.000000000000001) ** 2 == 36)
 
 
-def dichotomie(liste: list[any], element: any, start: int = 0, end: int = None, bypass_sorting: bool = False) -> int:
+def dichotomie(
+    liste: list[any],
+    element: any,
+    start: int = 0,
+    end: int = None,
+    bypass_sorting: bool = False,
+) -> int:
     """Recherche la partie entière de la racine carrée d'un nombre en utilisant une recherche dichotomique.
 
     Args:
@@ -45,6 +52,7 @@ def dichotomie(liste: list[any], element: any, start: int = 0, end: int = None,
     else:
         return dichotomie(liste, element, start, middle - 1, bypass_sorting=True)
 
+
 def racine_dich(number: int) -> int:
     """
     Calcul de la partie entière de la racine carrée d'un nombre entier.
@@ -60,7 +68,6 @@ def racine_dich(number: int) -> int:
     return dichotomie(liste, number)
 
 
-
 if __name__ == "__main__":
     print(racine_dich(36))  # Retourne 6
     print(racine_dich(20))  # Retourne 4

trees/genealogie/genealogie.py

@@ -124,7 +124,9 @@ class Arbre(object):
             return Arbre(racine=elt)
         else:
             return Arbre(elt, self)
+
     def enlever(self, elt):
         pass
+
     def display(self):
         pass

turing/machine.py

@@ -5,25 +5,25 @@ class Tape:
 
     def read(self):
         if self.head < 0:
-            self.tape = ['•'] * (-self.head) + self.tape
+            self.tape = ["•"] * (-self.head) + self.tape
             self.head = 0
         elif self.head >= len(self.tape):
-            self.tape += ['•'] * (self.head - len(self.tape) + 1)
+            self.tape += ["•"] * (self.head - len(self.tape) + 1)
         return self.tape[self.head]
 
     def write(self, symbol):
         self.tape[self.head] = symbol
 
     def move(self, direction):
-        if direction == 'g':
+        if direction == "g":
             self.head -= 1
-        elif direction == 'd':
+        elif direction == "d":
             self.head += 1
 
     def __str__(self):
-        tape_str = ''.join(self.tape)
+        tape_str = "".join(self.tape)
-        pointer = ' ' * self.head + '^'
+        pointer = " " * self.head + "^"
-        return f'{tape_str}\n{pointer}'
+        return f"{tape_str}\n{pointer}"
 
 
 class TuringMachine:
@@ -37,10 +37,15 @@ class TuringMachine:
         steps = 0
         while self.state != self.final_state:
             current_symbol = tape.read()
-            if self.state not in self.transitions or current_symbol not in self.transitions[self.state]:
+            if (
+                self.state not in self.transitions
+                or current_symbol not in self.transitions[self.state]
+            ):
                 print("No transition rule found. Halting.")
                 break
-            write_symbol, direction, next_state = self.transitions[self.state][current_symbol]
+            write_symbol, direction, next_state = self.transitions[self.state][
+                current_symbol
+            ]
             tape.write(write_symbol)
             tape.move(direction)
             self.state = next_state
@@ -51,12 +56,7 @@ class TuringMachine:
 
 
 transitions = {
-    'init': {
+    "init": {"1": ("1", "d", "init"), "0": ("0", "d", "init"), "•": ("1", "g", "end")}
-        '1': ('1', 'd', 'init'),
-        '0': ('0', 'd', 'init'),
-        '•': ('1', 'g', 'end')  # ajoute un 1 à la fin
 }
-}
+tm = TuringMachine(transitions, initial_state="init", final_state="end")
-tm = TuringMachine(transitions, initial_state='init', final_state='end')
 tm.run("1011")
-

turing/mc.py

@@ -15,3 +15,5 @@ class Configuration:
 if __name__ == "__main__":
     ruban = Ta
 
+
+class Machine: