Add university content

high-school/graphes/maze/fifo.py

@@ -0,0 +1,20 @@
+class Pile:
+    def __init__(self) -> None:
+        self.element = []
+
+    def empiler(self, element) -> None:
+        self.element.append(element)
+
+    def est_vide(self) -> bool:
+        return len(self.element) == 0
+
+    def defiler(self):
+        assert not self.est_vide(), "La pile est vide"
+        return self.element.pop()
+
+    def size(self) -> int:
+        return len(self.element)
+
+    def index(self, k):
+        assert not self.est_vide(), "La pile est vide"
+        return self.element[k]

high-school/graphes/maze/lifo.py

@@ -0,0 +1,20 @@
+class Queue:
+    def __init__(self) -> None:
+        self.element = []
+
+    def enfiler(self, element):
+        self.element.append(element)
+
+    def est_vide(self):
+        return len(self.element) == 0
+
+    def defiler(self):
+        assert self.est_vide(), "La file est vide"
+        return self.element.pop(0)
+
+    def size(self):
+        return len(self.element)
+
+    def index(self, k):
+        assert self.est_vide(), "La file est vide"
+        return self.element[k]

high-school/graphes/maze/main.py

@@ -0,0 +1,7 @@
+import maze_creator as mc
+
+
+lab = mc.Labyrinth(10, 10)
+lab.set_start_end((0, 0), (100, 100))
+lab.generate_maze()
+print(lab.__str__())

high-school/graphes/maze/maze_creator.py

@@ -0,0 +1,78 @@
+import random as rnd
+
+
+class Labyrinth:
+    def __init__(self, rows, cols) -> None:
+        self.rows = rows
+        self.cols = cols
+        # Grille initiale : 1 = mur, 0 = chemin
+        self.grid = [[1 for _ in range(cols)] for _ in range(rows)]
+        self.start = None
+        self.end = None
+
+    def voisins(self, x, y):
+        """
+        Retourne les voisins valides (encore des murs) de la cellule (x, y).
+        """
+        directions = [(0, 2), (0, -2), (2, 0), (-2, 0)]
+        voisins = []
+
+        for dx, dy in directions:
+            nx, ny = x + dx, y + dy
+            if 0 <= nx < self.rows and 0 <= ny < self.cols and self.grid[nx][ny] == 1:
+                voisins.append((nx, ny))
+
+        return voisins
+
+    def casser_mur(self, x1, y1, x2, y2):
+        """
+        Casse le mur entre les cellules (x1, y1) et (x2, y2).
+        """
+        mx, my = (x1 + x2) // 2, (y1 + y2) // 2  # Coordonnées du mur à casser
+        self.grid[mx][my] = 0  # Transformer le mur en chemin
+        self.grid[x2][y2] = 0  # Transformer la cellule voisine en chemin
+
+    def generate_maze(self):
+        """
+        Génère un labyrinthe parfait à l'aide de l'algorithme de Prim.
+        """
+        # Choisir une cellule de départ aléatoire
+        x, y = rnd.randrange(0, self.rows, 2), rnd.randrange(0, self.cols, 2)
+        self.grid[x][y] = 0  # Transformer la cellule en chemin
+
+        # Liste des murs candidats (voisins de la cellule initiale)
+        murs = self.voisins(x, y)
+
+        while murs:
+            # Choisir un mur aléatoire
+            nx, ny = rnd.choice(murs)
+            murs.remove((nx, ny))
+
+            # 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
+                ):
+                    # Casser le mur entre les deux cellules
+                    self.casser_mur(cx, cy, nx, ny)
+                    # Ajouter les nouveaux murs adjacents
+                    murs.extend(self.voisins(nx, ny))
+                    break
+
+    def set_start_end(self, start, end):
+        """
+        Définit les points de départ et d'arrivée du labyrinthe.
+        """
+        self.start = start
+        self.end = end
+
+    def __str__(self) -> str:
+        """
+        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
+        )

high-school/graphes/maze/test.py

@@ -0,0 +1,54 @@
+from fifo import (
+    Pile,
+)  # Remplacez "fifo" par le nom exact de votre fichier contenant la classe Pile
+
+# Initialisation
+pile = Pile()
+
+# Test de empiler
+pile.empiler(5)
+pile.empiler(10)
+assert pile.size() == 2, "Erreur : La taille de la pile devrait être 2"
+assert pile.element == [5, 10], "Erreur : Les éléments de la pile ne correspondent pas"
+
+# Test de est_vide
+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"
+
+# Test de defiler
+pile.empiler(7)
+pile.empiler(3)
+assert pile.defiler() == 3, "Erreur : Le dernier élément défilé devrait être 3"
+assert pile.defiler() == 7, "Erreur : Le dernier élément défilé devrait être 7"
+try:
+    pile.defiler()
+    assert False, "Erreur : defiler devrait lever une exception pour une pile vide"
+except AssertionError as e:
+    pass  # Test réussi
+
+# Test de size
+pile.empiler(4)
+assert pile.size() == 1, "Erreur : La taille de la pile devrait être 1"
+pile.defiler()
+assert pile.size() == 0, "Erreur : La taille de la pile devrait être 0 après defiler"
+
+# Test de index
+pile.empiler(1)
+pile.empiler(2)
+pile.empiler(3)
+assert pile.index(0) == 1, "Erreur : L'élément à l'index 0 devrait être 1"
+assert pile.index(2) == 3, "Erreur : L'élément à l'index 2 devrait être 3"
+try:
+    pile.defiler()
+    pile.defiler()
+    pile.defiler()
+    pile.index(0)
+    assert False, "Erreur : index devrait lever une exception pour une pile vide"
+except AssertionError as e:
+    pass  # Test réussi
+
+print("Tous les tests sont passés avec succès !")