From e03e5458aa765ce7e08260250443321de129202a Mon Sep 17 00:00:00 2001 From: Spectre Date: Tue, 1 Apr 2025 14:28:43 +0200 Subject: [PATCH] formatte file --- Dijkstra/algo.py | 26 +- Partie2/Eleve/Projet/control.py | 5 +- TDliste2liste/exercice1.py | 7 +- TDliste2liste/exercice2.py | 4 +- TDliste2liste/exercice3.py | 7 +- TDliste2liste/exercice4.py | 3 +- TDliste2liste/exercice5.py | 5 +- TDliste2liste/exercice6.py | 2 + casse-brique/main.py | 125 ++-- cesar/chiffrement.py | 4 + crypto/algo.py | 14 +- ensembles_dynamiques/TP/_collection.py | 21 +- ensembles_dynamiques/TP/_collection_list.py | 20 +- ensembles_dynamiques/TP/_sommets.py | 33 +- ensembles_dynamiques/TP/_sommets_dict.py | 45 +- ensembles_dynamiques/TP/main.py | 23 +- fibonacci/code1.py | 13 +- fibonacci/complex.py | 15 +- file/old/LSC.py | 19 +- file/old/file.py | 5 +- file/old/file_LSC.py | 1 + fonctions_tri/partitionement.py | 46 +- graphes/DS_possible/main.py | 25 +- graphes/homework_wednesday.py | 30 +- graphes/leaudibidon/Water_jug.py | 554 +++++++++--------- graphes/leaudibidon/correction.py | 32 +- graphes/leaudibidon/main.py | 28 +- graphes/maze/fifo.py | 6 +- graphes/maze/lifo.py | 4 +- graphes/maze/main.py | 4 +- graphes/maze/maze_creator.py | 14 +- graphes/maze/test.py | 9 +- graphes/monday_homework.py | 5 +- magic_square/TDliste2liste/exercice1.py | 7 +- magic_square/TDliste2liste/exercice2.py | 4 +- magic_square/TDliste2liste/exercice3.py | 7 +- magic_square/TDliste2liste/exercice4.py | 3 +- magic_square/TDliste2liste/exercice5.py | 5 +- magic_square/TDliste2liste/exercice6.py | 2 + magic_square/magic_square.py | 30 +- magic_square/td_carre_magique.py | 29 +- partition_fusion/code.py | 8 +- partition_fusion/code2.py | 27 +- partition_fusion/liste.py | 16 +- partition_fusion/partition_fusion.py | 33 +- perfect_number/main.py | 9 +- pygame/V2/balle/balle.py | 50 +- pygame/V2/balle/balle_rebondissante.py | 53 +- pygame/V2/balle/casse_brique.py | 24 +- pygame/V2/balle/constantes.py | 2 +- pygame/V2/balle/raquette.py | 67 ++- pygame/bouncing_ball/ball.py | 41 +- pygame/bouncing_ball/balle.py | 39 +- pygame/bouncing_ball/constantes.py | 3 +- pygame/bouncing_ball/raquette.py | 9 +- pygame/bouncing_ball_project/ball.py | 41 +- pygame/bouncing_ball_project/balle.py | 5 +- .../bouncing_ball_game.py | 8 +- pygame/bouncing_ball_project/constantes.py | 3 +- pygame/bouncing_ball_project/raquette.py | 14 +- pygame/lab_py/main.py | 57 +- recursivite/TD1.py | 28 +- .../dichotomie/iteratif/main.py | 13 +- .../dichotomie/iteratif/tester.py | 72 ++- .../dichotomie/recursif/correction/V1.py | 23 +- .../dichotomie/recursif/myself/idx/main.py | 17 +- .../dichotomie/recursif/myself/idx/tester.py | 85 ++- .../dichotomie/recursif/myself/main.py | 17 +- .../dichotomie/recursif/myself/tester.py | 72 ++- recursivite/exercice_MJoannic/palindrom.py | 5 +- .../exercice_MJoannic/sqrt/correction/main.py | 23 +- recursivite/exercice_MJoannic/sqrt/main.py | 21 +- trees/genealogie/genealogie.py | 8 +- trees/qdj.py | 8 +- {python => turing}/bitab.py | 0 turing/machine.py | 32 +- turing/mc.py | 2 + 77 files changed, 1231 insertions(+), 945 deletions(-) rename {python => turing}/bitab.py (100%) diff --git a/Dijkstra/algo.py b/Dijkstra/algo.py index ebcc86c..24dd26c 100644 --- a/Dijkstra/algo.py +++ b/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)], - 'B': [('C', 5), ('D', 10)], - 'C': [('D', 3), ('E', 8)], - 'D': [('E', 4), ('F', 11)], - 'E': [('G', 6)], - 'F': [('G', 2)], - 'G': [] + "A": [("B", 4), ("C", 2)], + "B": [("C", 5), ("D", 10)], + "C": [("D", 3), ("E", 8)], + "D": [("E", 4), ("F", 11)], + "E": [("G", 6)], + "F": [("G", 2)], + "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']}" + ) diff --git a/Partie2/Eleve/Projet/control.py b/Partie2/Eleve/Projet/control.py index c150743..8a31822 100644 --- a/Partie2/Eleve/Projet/control.py +++ b/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") diff --git a/TDliste2liste/exercice1.py b/TDliste2liste/exercice1.py index f0a9683..5040495 100644 --- a/TDliste2liste/exercice1.py +++ b/TDliste2liste/exercice1.py @@ -1,4 +1,4 @@ -def appartient(elt,tableau): +def appartient(elt, tableau): for i in tableau: if i == elt: return True @@ -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])) + 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])) diff --git a/TDliste2liste/exercice2.py b/TDliste2liste/exercice2.py index 2f7708e..b6a2023 100644 --- a/TDliste2liste/exercice2.py +++ b/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,7 +16,8 @@ def indice_max(tableau): else: continue + if __name__ == "__main__": - l1 = [0,2,3,4,5,6,7,8,9,90,91,59,1] + l1 = [0, 2, 3, 4, 5, 6, 7, 8, 9, 90, 91, 59, 1] print(max_local(l1)) print(indice_max(l1)) diff --git a/TDliste2liste/exercice3.py b/TDliste2liste/exercice3.py index 7566bd1..752d100 100644 --- a/TDliste2liste/exercice3.py +++ b/TDliste2liste/exercice3.py @@ -1,8 +1,11 @@ -def cree_tableau_n_m(n,m): +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_n_m(3, 5)) print(cree_tableau_carre_n(5)) diff --git a/TDliste2liste/exercice4.py b/TDliste2liste/exercice4.py index 814150f..281129a 100644 --- a/TDliste2liste/exercice4.py +++ b/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)) diff --git a/TDliste2liste/exercice5.py b/TDliste2liste/exercice5.py index 6471d60..a10682a 100644 --- a/TDliste2liste/exercice5.py +++ b/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 diff --git a/TDliste2liste/exercice6.py b/TDliste2liste/exercice6.py index 7881f21..6017e5c 100644 --- a/TDliste2liste/exercice6.py +++ b/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))] diff --git a/casse-brique/main.py b/casse-brique/main.py index 41bf370..4e5d961 100644 --- a/casse-brique/main.py +++ b/casse-brique/main.py @@ -13,8 +13,8 @@ SCREEN_HEIGHT = 720 # Définition des couleurs (R, G, B) BLACK = (0, 0, 0) WHITE = (255, 255, 255) -BLUE = (0, 0, 255) -RED = (255, 0, 0) +BLUE = (0, 0, 255) +RED = (255, 0, 0) # Création de la fenêtre de jeu screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) @@ -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 @@ -32,22 +33,24 @@ def show_menu(): button_height = 50 button_rect = pygame.Rect(0, 0, button_width, button_height) button_rect.center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2) - + while menu_running: clock.tick(FPS) screen.fill(BLACK) - + # 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" pygame.draw.rect(screen, BLUE, button_rect) button_text = button_font.render("Jouer", True, WHITE) button_text_rect = button_text.get_rect(center=button_rect.center) screen.blit(button_text, button_text_rect) - + # Gestion des événements du menu for event in pygame.event.get(): if event.type == pygame.QUIT: @@ -57,32 +60,35 @@ def show_menu(): if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: if button_rect.collidepoint(event.pos): menu_running = False - + pygame.display.flip() + # Fonction principale du jeu def game_loop(): # Paramètres de la raquette PADDLE_WIDTH = 100 PADDLE_HEIGHT = 15 paddle_x = (SCREEN_WIDTH - PADDLE_WIDTH) / 2 # centré horizontalement - paddle_y = SCREEN_HEIGHT - PADDLE_HEIGHT - 10 # position verticale en bas + paddle_y = SCREEN_HEIGHT - PADDLE_HEIGHT - 10 # position verticale en bas paddle_speed = 7 # Paramètres de la balle ball_radius = 10 # Liste de balles (initialement une seule) - balls = [{ - 'x': SCREEN_WIDTH / 2, - 'y': SCREEN_HEIGHT / 2, - 'radius': ball_radius, - 'speed_x': 9 * random.choice([-1, 1]), - 'speed_y': -9 - }] + balls = [ + { + "x": SCREEN_WIDTH / 2, + "y": SCREEN_HEIGHT / 2, + "radius": ball_radius, + "speed_x": 9 * random.choice([-1, 1]), + "speed_y": -9, + } + ] # Paramètres des briques - BRICK_ROWS = 5 # nombre de lignes de briques - BRICK_COLUMNS = 10 # nombre de colonnes de briques + BRICK_ROWS = 5 # nombre de lignes de briques + BRICK_COLUMNS = 10 # nombre de colonnes de briques BRICK_WIDTH = SCREEN_WIDTH // BRICK_COLUMNS BRICK_HEIGHT = 20 brick_padding = 5 @@ -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['y'] += ball['speed_y'] + ball["x"] += ball["speed_x"] + ball["y"] += ball["speed_y"] # Collision avec les murs latéraux - if ball['x'] - ball['radius'] <= 0 or ball['x'] + ball['radius'] >= SCREEN_WIDTH: - ball['speed_x'] *= -1 + if ( + 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: - ball['speed_y'] *= -1 + if ball["y"] - ball["radius"] <= 0: + 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['radius'] * 2, ball['radius'] * 2) + ball_rect = pygame.Rect( + 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: - ball['speed_y'] *= -1 # Inversion de la vitesse verticale - offset = (ball['x'] - (paddle_x + PADDLE_WIDTH / 2)) / (PADDLE_WIDTH / 2) - ball['speed_x'] = 4 * offset + if ball_rect.colliderect(paddle_rect) and ball["speed_y"] > 0: + ball["speed_y"] *= -1 # Inversion de la vitesse verticale + offset = (ball["x"] - (paddle_x + PADDLE_WIDTH / 2)) / ( + 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'] += random.choice([-1, 1]) + new_ball["speed_x"] *= -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'] - dy = balls[i]['y'] - balls[j]['y'] + dx = balls[i]["x"] - balls[j]["x"] + 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_y'], balls[j]['speed_y'] = balls[j]['speed_y'], balls[i]['speed_y'] + balls[i]["speed_x"], balls[j]["speed_x"] = ( + 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]['y'] += ny * overlap / 2 - balls[j]['x'] -= nx * overlap / 2 - balls[j]['y'] -= ny * overlap / 2 + balls[i]["x"] += nx * overlap / 2 + balls[i]["y"] += ny * overlap / 2 + balls[j]["x"] -= nx * 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 - diff --git a/cesar/chiffrement.py b/cesar/chiffrement.py index 269e61d..b05a392 100644 --- a/cesar/chiffrement.py +++ b/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) diff --git a/crypto/algo.py b/crypto/algo.py index c9f7066..9536113 100644 --- a/crypto/algo.py +++ b/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)] + 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 diff --git a/ensembles_dynamiques/TP/_collection.py b/ensembles_dynamiques/TP/_collection.py index 772e807..9442cd6 100644 --- a/ensembles_dynamiques/TP/_collection.py +++ 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. @@ -26,11 +27,12 @@ def initialiser_ensemble(): Pré-condition : - aucune - Effet de bord + Effet de bord - aucune """ 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,10 +92,11 @@ def ajouter(ensemble, element): resultat.add(element) return resultat + def supprimer(ensemble, element): """ Construire une copie de l'ensemble privé d'un élément. - Si l'élément à supprimer n'est pas dans l'ensemble initial, + Si l'élément à supprimer n'est pas dans l'ensemble initial, alors une copie intégrale est renvoyée. Paramètres : @@ -103,11 +108,12 @@ def supprimer(ensemble, element): """ resultat = initialiser_ensemble() for _ in ensemble: - if not(_ == element): + if not (_ == element): resultat = ajouter(resultat, _) return resultat -def rechercher(ensemble, cle, critere = lambda x, y: x==y): + +def rechercher(ensemble, cle, critere=lambda x, y: x == y): """ Construit la sous-collection constituée des éléments d'un ensemble dont la clé satisfait un critère donné. @@ -132,9 +138,10 @@ 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, + Construit la collection des éléments d'un ensemble, dont la clé satisfait le critère donné. Paramètres : @@ -157,9 +164,10 @@ def supprimer_critere(ensemble, cle, critere): resultat = supprimer(resultat, _) return resultat + def lister(ensemble, affichage=print): """ - Afficher le contenu d'un ensemble, + Afficher le contenu d'un ensemble, en formattant chaque élément selon la fonction d'affichage fournie. Paramètres : @@ -180,6 +188,5 @@ def lister(ensemble, affichage=print): return None - if __name__ == "__main__": pass diff --git a/ensembles_dynamiques/TP/_collection_list.py b/ensembles_dynamiques/TP/_collection_list.py index a14dffc..63cd5b9 100644 --- a/ensembles_dynamiques/TP/_collection_list.py +++ b/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,10 +89,11 @@ def ajouter(ensemble, element): copie.append(element) return copie + def supprimer(ensemble, element): """ Construire une copie de l'ensemble privé d'un élément. - Si l'élément à supprimer n'est pas dans l'ensemble initial, + Si l'élément à supprimer n'est pas dans l'ensemble initial, alors une copie intégrale est renvoyée. Paramètres : @@ -101,7 +106,8 @@ def supprimer(ensemble, element): resultat = ensemble[:] return resultat.remove(element) -def rechercher(ensemble, cle, critere = lambda x, y: x==y): + +def rechercher(ensemble, cle, critere=lambda x, y: x == y): """ Construit la sous-collection constituée des éléments d'un ensemble dont la clé satisfait un critère donné. @@ -122,9 +128,10 @@ 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, + Construit la collection des éléments d'un ensemble, dont la clé satisfait le critère donné. Paramètres : @@ -141,11 +148,12 @@ def supprimer_critere(ensemble, cle, critere): Effet de bord : - aucun """ - return [element for element in ensemble if not critere(element,cle)] + return [element for element in ensemble if not critere(element, cle)] + def lister(ensemble, affichage=print): """ - Afficher le contenu d'un ensemble, + Afficher le contenu d'un ensemble, en formattant chaque élément selon la fonction d'affichage fournie. Paramètres : @@ -163,5 +171,7 @@ def lister(ensemble, affichage=print): """ for item in ensemble: affichage(item) + + if __name__ == "__main__": pass diff --git a/ensembles_dynamiques/TP/_sommets.py b/ensembles_dynamiques/TP/_sommets.py index 5ab3cee..63cb51d 100644 --- a/ensembles_dynamiques/TP/_sommets.py +++ b/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. @@ -30,11 +31,12 @@ def creer_sommet(nom, altitude, massif): Pré-condition : - aucune (programmation défensive à envisager) - Effet de bord : - - aucun + Effet de bord : + - aucun """ return (nom, altitude, massif) + def altitude_en_m(altitude): """ Conversion de l'altitude en entier ("2 062 m" -> 2062) @@ -51,18 +53,19 @@ 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. Paramètres : - - ligne : STR, ligne du fichier csv + - ligne : STR, ligne du fichier csv - massif : STR, basename du fichier contenant la ligne Résultat : @@ -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 @@ -111,10 +116,11 @@ def nom(sommet): - aucune Effet de bord : - - aucun + - aucun """ return sommet[0] + def altitude(sommet): """ Consulte l'altitude d'un sommet @@ -129,10 +135,11 @@ def altitude(sommet): - aucune Effet de bord : - - aucun + - aucun """ return sommet[1] + def massif(sommet): """ Consulte le massif d'un sommet @@ -147,10 +154,11 @@ def massif(sommet): - aucune Effet de bord : - - aucun + - aucun """ return sommet[2] + def coincide_nom(sommet, motif): """ Compare le nom du sommet au motif @@ -169,7 +177,8 @@ def coincide_nom(sommet, motif): - aucun """ nom_sommet = nom(sommet) - return (len(motif) <= len(nom_sommet)) and (nom_sommet[:len(motif)] == motif) + return (len(motif) <= len(nom_sommet)) and (nom_sommet[: len(motif)] == motif) -if __name__ == '__main__': + +if __name__ == "__main__": pass diff --git a/ensembles_dynamiques/TP/_sommets_dict.py b/ensembles_dynamiques/TP/_sommets_dict.py index 5c27225..97c299f 100644 --- a/ensembles_dynamiques/TP/_sommets_dict.py +++ b/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. @@ -31,17 +32,14 @@ def creer_sommet(nom, altitude, massif): Pré-condition : - aucune (programmation défensive à envisager) - Effet de bord : - - aucun + Effet de bord : + - aucun """ - sommet = { - "Nom": nom, - "Altitude": altitude, - "Massif": massif - } + sommet = {"Nom": nom, "Altitude": altitude, "Massif": massif} return sommet + def altitude_en_m(altitude): """ Conversion de l'altitude en entier ("2 062 m" -> 2062) @@ -58,18 +56,19 @@ 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. Paramètres : - - ligne : STR, ligne du fichier csv + - ligne : STR, ligne du fichier csv - massif : STR, basename du fichier contenant la ligne Résultat : @@ -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): @@ -118,9 +120,11 @@ def nom(sommet): - aucune Effet de bord : - - aucun + - aucun """ return sommet["Nom"] + + def altitude(sommet): """ Consulte l'altitude d'un sommet @@ -135,9 +139,11 @@ def altitude(sommet): - aucune Effet de bord : - - aucun + - aucun """ - return sommet['Altitude'] + return sommet["Altitude"] + + def massif(sommet): """ Consulte le massif d'un sommet @@ -152,9 +158,11 @@ def massif(sommet): - aucune Effet de bord : - - aucun + - aucun """ return sommet["Massif"] + + def coincide_nom(sommet, motif): """ Compare le nom du sommet au motif @@ -174,7 +182,8 @@ def coincide_nom(sommet, motif): """ nom_sommet = nom(sommet) - return (len(motif) <= len(nom_sommet)) and (nom_sommet[:len(motif)] == motif) + return (len(motif) <= len(nom_sommet)) and (nom_sommet[: len(motif)] == motif) -if __name__ == '__main__': + +if __name__ == "__main__": pass diff --git a/ensembles_dynamiques/TP/main.py b/ensembles_dynamiques/TP/main.py index b09b2b7..dd86f77 100644 --- a/ensembles_dynamiques/TP/main.py +++ b/ensembles_dynamiques/TP/main.py @@ -16,17 +16,18 @@ 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. Paramètres : - fichier : STR, le nom complet du fichier csv à parcourir - Résultat : + Résultat : - resultat : ENSEMBLE, la collection des sommets - Pré-conditions : + Pré-conditions : - aucune Effets de bord : @@ -41,27 +42,29 @@ 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 + Recherche les sommets de la collection dont le nom correspond à un motif donné. Paramètres : - ensemble : ENSEMBLE, la collection des somets - motif : STR, la chaîne de caractères à identifier - Résultat : + Résultat : - ENSEMBLE, la sous-collection des sommets satisfaisant au critère - Pré-condition : + Pré-condition : - aucune Effet de bord : - - aucun + - aucun """ return col.rechercher(ensemble, motif, som.coincide_nom) -if __name__ == '__main__': - col.lister(col.supprimer_critere(file_2_set(), 'Grand', som.coincide_nom), \ - som.afficher) +if __name__ == "__main__": + col.lister( + col.supprimer_critere(file_2_set(), "Grand", som.coincide_nom), som.afficher + ) diff --git a/fibonacci/code1.py b/fibonacci/code1.py index 725b276..c4c2e8e 100644 --- a/fibonacci/code1.py +++ b/fibonacci/code1.py @@ -1,13 +1,18 @@ import numpy as np + + def fibobo(n): - if n<= 1: + if n <= 1: return n - return fibobo(n-1) + fibobo(n-2) + return fibobo(n - 1) + fibobo(n - 2) print(fibobo(30)) + def fibibi(n): - fibi = np.array([[1,1],[1,0]]) - return np.linalg.matrix_power(fibi,n)[0][-1] + fibi = np.array([[1, 1], [1, 0]]) + return np.linalg.matrix_power(fibi, n)[0][-1] + + print(fibibi(100)) diff --git a/fibonacci/complex.py b/fibonacci/complex.py index b0fa285..9ac86cf 100644 --- a/fibonacci/complex.py +++ b/fibonacci/complex.py @@ -3,19 +3,24 @@ 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_matrix = range(1, 50, 1) # Limiter n pour éviter les dépassements avec 2^n +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 times_recursive = [] @@ -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") diff --git a/file/old/LSC.py b/file/old/LSC.py index a0cd9c8..09ec56c 100644 --- a/file/old/LSC.py +++ b/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): """ @@ -76,7 +76,7 @@ class Liste_Simplement_Chainee(object): donnee en tete. """ - assert not(self.est_vide()), "Liste Vide" + assert not (self.est_vide()), "Liste Vide" return self._tete.donnee def queue(self): @@ -89,12 +89,13 @@ class Liste_Simplement_Chainee(object): Queue de la liste. """ - assert not(self.est_vide()), "Liste Vide" + assert not (self.est_vide()), "Liste Vide" return self._tete.suite # ############################################################################ + 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|') - while not(est_vide(reste)) and (taille == -1 or compteur < taille): - print('+- {}\n|'.format(str(tete(reste)))) + print("+-----\n|") + while not (est_vide(reste)) and (taille == -1 or compteur < taille): + 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. diff --git a/file/old/file.py b/file/old/file.py index 20e20b8..bacf408 100644 --- a/file/old/file.py +++ b/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] - diff --git a/file/old/file_LSC.py b/file/old/file_LSC.py index a6d6869..e180bc3 100644 --- a/file/old/file_LSC.py +++ b/file/old/file_LSC.py @@ -1,4 +1,5 @@ import LSC as lifo + def creer_liste_vide(): return lifo.cr diff --git a/fonctions_tri/partitionement.py b/fonctions_tri/partitionement.py index a23604c..cc20dfd 100644 --- a/fonctions_tri/partitionement.py +++ b/fonctions_tri/partitionement.py @@ -1,6 +1,7 @@ from typing import Any -def partitionement(liste: list[Any],debut,fin): + +def partitionement(liste: list[Any], debut, fin): pivot = liste[debut] gauche = debut + 1 droite = fin - 1 @@ -12,49 +13,16 @@ def partitionement(liste: list[Any],debut,fin): droite -= 1 if gauche < droite: - exchange(liste,gauche,droite) + exchange(liste, gauche, droite) gauche += 1 droite -= 1 - exchange(liste,droite,debut) + exchange(liste, droite, debut) return droite def exchange(liste, indx_g, indx_d): - liste[indx_g],liste[indx_d] = liste[indx_d], liste[indx_g] - - -l = [12,4,0,44,27] -print(partitionement(l,0,len(l)-1)) - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + liste[indx_g], liste[indx_d] = liste[indx_d], liste[indx_g] +l = [12, 4, 0, 44, 27] +print(partitionement(l, 0, len(l) - 1)) diff --git a/graphes/DS_possible/main.py b/graphes/DS_possible/main.py index 6d0c395..a774e32 100644 --- a/graphes/DS_possible/main.py +++ b/graphes/DS_possible/main.py @@ -1,27 +1,26 @@ graphe = { - "node1": ["node2","node4"], - "node2": ["node2","node3","node6"], + "node1": ["node2", "node4"], + "node2": ["node2", "node3", "node6"], "node3": ["node5"], - "node5": ["node5","node6"], - "node4": ["node1","node5"], - "node6": [] + "node5": ["node5", "node6"], + "node4": ["node1", "node5"], + "node6": [], } print(graphe["node1"]) + + def bfs(graphe, start_node): queue = [start_node] - + visited = set() while queue: - node = queue.pop(0) + node = queue.pop(0) if node not in visited: - print(node) - visited.add(node) + print(node) + visited.add(node) for neighbor in graphe[node]: if neighbor not in visited: queue.append(neighbor) - - - -bfs(graphe,"node1") \ No newline at end of file +bfs(graphe, "node1") diff --git a/graphes/homework_wednesday.py b/graphes/homework_wednesday.py index 0199b61..a4eb975 100644 --- a/graphes/homework_wednesday.py +++ b/graphes/homework_wednesday.py @@ -2,29 +2,31 @@ 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} - + queue = [(0, source)] - + while queue: current_distance, current_node = heapq.heappop(queue) - + if current_distance > distances[current_node]: continue - + for neighbor, weight in graph[current_node]: distance = current_distance + weight if distance < distances[neighbor]: distances[neighbor] = distance previous[neighbor] = current_node heapq.heappush(queue, (distance, neighbor)) - + return distances, previous + def reconstruct_path(previous, start, end): path = [] node = end @@ -34,22 +36,22 @@ 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" destination = "R4" - + distances, previous = dijkstra(graph, source) - + print("Shortest distances from", source, ":", distances) - + path = reconstruct_path(previous, source, destination) print("Shortest path from", source, "to", destination, ":", path) - diff --git a/graphes/leaudibidon/Water_jug.py b/graphes/leaudibidon/Water_jug.py index 8911541..5103728 100644 --- a/graphes/leaudibidon/Water_jug.py +++ b/graphes/leaudibidon/Water_jug.py @@ -2,345 +2,367 @@ # -*- Coding: utf-8 -*- - class Graphe_Oriente(object): - """ - Classe des Graphes Orientés (GO). + """ + Classe des Graphes Orientés (GO). - Les graphes sont représentés par - - une liste de sommets - - leur liste d'adjacence + Les graphes sont représentés par + - une liste de sommets + - leur liste d'adjacence - Attributs (publics) - - sommets : liste des sommets - - voisins : dictionnaire des listes d'adjacence + Attributs (publics) + - sommets : liste des sommets + - voisins : dictionnaire des listes d'adjacence - Méthodes (publiques) - - ajoute_sommet : ajout d'un sommet - - ajoute_arcs : ajout d'un arc - """ + Méthodes (publiques) + - ajoute_sommet : ajout d'un sommet + - ajoute_arcs : ajout d'un arc + """ - def __init__(self): - self.sommets = list() - self.voisins = dict() - return None + def __init__(self): + self.sommets = list() + self.voisins = dict() + return None - def ajoute_sommet(self, s): - """ - Ajoute le sommet s à l'instance de GO. + def ajoute_sommet(self, s): + """ + Ajoute le sommet s à l'instance de GO. - :param s data: etiquette du sommet - """ + :param s data: etiquette du sommet + """ - self.sommets.append(s) - self.voisins[s] = list() - return None + self.sommets.append(s) + self.voisins[s] = list() + return None - def ajoute_arc(self, origine, extremite): - """ - Ajoute l'arc origine -> extremite à l'instance de GO. + def ajoute_arc(self, origine, extremite): + """ + Ajoute l'arc origine -> extremite à l'instance de GO. - :param self Graphe_Oriente: instance à laquelle ajouter un arc - :param origine data: un sommet de l'instance, origine de l'arc - :param extremite data: un sommet de l'instance, extremité de l'arc + :param self Graphe_Oriente: instance à laquelle ajouter un arc + :param origine data: un sommet de l'instance, origine de l'arc + :param extremite data: un sommet de l'instance, extremité de l'arc - :return None: + :return None: - :effet de bord: Modification de l'instance + :effet de bord: Modification de l'instance - :pré-condition: les sommets doivent exister - """ - assert origine in self.sommets, "{} inconnu".format(origine) - assert extremite in self.sommets, "{} inconnu".format(extremite) - self.voisins[origine].append(extremite) - return None + :pré-condition: les sommets doivent exister + """ + assert origine in self.sommets, "{} inconnu".format(origine) + assert extremite in self.sommets, "{} inconnu".format(extremite) + self.voisins[origine].append(extremite) + return None def construire_chemins(graphe, depart): - """ - Construit tous les cheminement du graphe de depart donné + """ + Construit tous les cheminement du graphe de depart donné - :param graphe GO: graphe à parcourir - :param depart data: sommet de départ dans le graphe + :param graphe GO: graphe à parcourir + :param depart data: sommet de départ dans le graphe - :return resultat dict: dictionnaire - - clef : sommet atteint - - valeur : tuple (longueur itinéraire, sommet prédécesseur) + :return resultat dict: dictionnaire + - clef : sommet atteint + - valeur : tuple (longueur itinéraire, sommet prédécesseur) - :effet de bord: Aucun - >>> graphe = Graphe_Oriente() - >>> graphe.ajoute_sommet('A') - >>> graphe.ajoute_sommet('B') - >>> graphe.ajoute_sommet('C') - >>> graphe.ajoute_arc('A', 'B') - >>> graphe.ajoute_arc('B', 'C') - >>> construire_chemins(graphe, 'A') - {'A': (0, None), 'B': (1, 'A'), 'C': (2, 'B')} - """ - resultat = dict() - file = [depart] # initialise une file (sous forme de liste ici) - resultat[depart] = (0, None) # None car le depart n'a aucun predesseceur - 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 - 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 + :effet de bord: Aucun + >>> graphe = Graphe_Oriente() + >>> graphe.ajoute_sommet('A') + >>> graphe.ajoute_sommet('B') + >>> graphe.ajoute_sommet('C') + >>> graphe.ajoute_arc('A', 'B') + >>> graphe.ajoute_arc('B', 'C') + >>> construire_chemins(graphe, 'A') + {'A': (0, None), 'B': (1, 'A'), 'C': (2, 'B')} + """ + resultat = dict() + file = [depart] # initialise une file (sous forme de liste ici) + resultat[depart] = (0, None) # None car le depart n'a aucun predesseceur + 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 + 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 + return resultat def reconstruire_chemin_vers(dico_chemins, *arrivee): - """ - Remonte tout l'itinéraire depuis un sommet fixé - vers un ou des sommets du graphe + """ + Remonte tout l'itinéraire depuis un sommet fixé + vers un ou des sommets du graphe - :param dico_chemins dict: table des longueurs/prédécessurs - :param *arrivee: nombre quelconque de sommet à atteindre - (si vide, on considère tous les sommets) - :return resultat list: liste des chemins ie des listes de sommets traversés - >>> dico_chemins = {'A': (0, None), 'B': (1, 'A'), 'C': (2, 'B')} - >>> reconstruire_chemin_vers(dico_chemins, 'C') - [['A', 'B', 'C']] - """ - 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) - 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) - current = dico_chemins[current][1] # on change current avec le sommet predesseceur pour que la boucle continue - chemins.append(sous_chemin) - return chemins + :param dico_chemins dict: table des longueurs/prédécessurs + :param *arrivee: nombre quelconque de sommet à atteindre + (si vide, on considère tous les sommets) + :return resultat list: liste des chemins ie des listes de sommets traversés + >>> dico_chemins = {'A': (0, None), 'B': (1, 'A'), 'C': (2, 'B')} + >>> reconstruire_chemin_vers(dico_chemins, 'C') + [['A', 'B', 'C']] + """ + 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) + 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) + current = dico_chemins[current][ + 1 + ] # on change current avec le sommet predesseceur pour que la boucle continue + chemins.append(sous_chemin) + return chemins def affichage_chemin(chemin): - """ - Produit le texte d'affichage d'un chemin + """ + Produit le texte d'affichage d'un chemin - :param chemin list: liste des sommets constituant le chemin - :return string: chemin mis en forme pour affichage - """ - long = len(chemin) - 1 - return "{} etapes :\n".format(long) + "\n\t-> ".join( - [str(sommet) for sommet in chemin] - ) + :param chemin list: liste des sommets constituant le chemin + :return string: chemin mis en forme pour affichage + """ + long = len(chemin) - 1 + return "{} etapes :\n".format(long) + "\n\t-> ".join( + [str(sommet) for sommet in chemin] + ) # DEFINITION DES OPERATIONS DE TRANSITION def vider(numero, etat): - """ - Vide un bidon + """ + Vide un bidon - :param numero INT: index du bidon - :param etat tuple: etat des bidons avant l'opération - :return tuple: nouvel etat aprés opération - :effet de bord: aucun - >>> vider(1,(3,5,2)) - (3, 0, 2) - """ - index_b = list(etat) - index_b[numero] = 0 - return tuple(index_b) + :param numero INT: index du bidon + :param etat tuple: etat des bidons avant l'opération + :return tuple: nouvel etat aprés opération + :effet de bord: aucun + >>> vider(1,(3,5,2)) + (3, 0, 2) + """ + index_b = list(etat) + index_b[numero] = 0 + return tuple(index_b) def remplir(numero, etat, capacites): - """ - Remplit un bidon + """ + Remplit un bidon - :param numero INT: index du bidon - :param etat tuple: etat des bidons avant l'opération - :param capacites tuple: capacités des bidons - :return tuple: nouvel etat aprés opération - :effet de bord: aucun + :param numero INT: index du bidon + :param etat tuple: etat des bidons avant l'opération + :param capacites tuple: capacités des bidons + :return tuple: nouvel etat aprés opération + :effet de bord: aucun - >>> remplir(1, (3, 2, 1), (5, 4, 3)) - (3, 4, 1) - """ - cap = list(capacites) - index_b = list(etat) - index_b[numero] = cap[numero] - return tuple(index_b) + >>> remplir(1, (3, 2, 1), (5, 4, 3)) + (3, 4, 1) + """ + cap = list(capacites) + index_b = list(etat) + index_b[numero] = cap[numero] + return tuple(index_b) def transvaser(source, destination, etat, capacites): - """ - Transvase un bidon dans un autre + """ + Transvase un bidon dans un autre - :param origine int: index du bidon source - :param destination int: index du bidon destination - :param etas tuple: etat des bidons avant l'opération - :param capacites tuple: capacités des bidons - :return tuple: nouvel etat aprés opération - :effet de bord: aucun - >>> transvaser(0, 1, (3, 2, 1), (5, 4, 3)) - (1, 4, 1) - """ - transfer_amount = min( - list(etat)[source], list(capacites)[destination] - list(etat)[destination] - ) - new_state = list(etat) + :param origine int: index du bidon source + :param destination int: index du bidon destination + :param etas tuple: etat des bidons avant l'opération + :param capacites tuple: capacités des bidons + :return tuple: nouvel etat aprés opération + :effet de bord: aucun + >>> transvaser(0, 1, (3, 2, 1), (5, 4, 3)) + (1, 4, 1) + """ + transfer_amount = min( + list(etat)[source], list(capacites)[destination] - list(etat)[destination] + ) + new_state = list(etat) - new_state[source] -= transfer_amount - new_state[destination] += transfer_amount - return tuple(new_state) + new_state[source] -= transfer_amount + new_state[destination] += transfer_amount + return tuple(new_state) # FONCTION LIEES AU GRAPHE DU WATER_JUG + # Pour construire les etats def produit_cartesien(*listes): - """ - Concatène les tuples issus des différentes listes + """ + Concatène les tuples issus des différentes listes - :param *listes: un nombre quelconque de listes de tuples - :return list: une liste des tuples concaténés + :param *listes: un nombre quelconque de listes de tuples + :return list: une liste des tuples concaténés - Exemple - -------- - >>> produit_cartesien([(1,2), (3, 4)], [(5, 6), (7, 8,)]) - [(1, 2, 5, 6), (1, 2, 7, 8), (3, 4, 5, 6), (3, 4, 7, 8)] - """ - if listes == None: - return [] - if len(listes) == 1: - return listes[0] - result = [] - for elt in listes[0]: - for tuples in produit_cartesien(*listes[1:]): - result.append(elt + tuples) - return result + Exemple + -------- + >>> produit_cartesien([(1,2), (3, 4)], [(5, 6), (7, 8,)]) + [(1, 2, 5, 6), (1, 2, 7, 8), (3, 4, 5, 6), (3, 4, 7, 8)] + """ + if listes == None: + return [] + if len(listes) == 1: + return listes[0] + result = [] + for elt in listes[0]: + for tuples in produit_cartesien(*listes[1:]): + result.append(elt + tuples) + return result def creer_water_jug(*capacites): - """ - Création du graphe de Water Jug en fonction des capacités des bidons + """ + Création du graphe de Water Jug en fonction des capacités des bidons - :param *capacites: capacités des bidons disponibles - :return resultat GO: le graphe orienté du W_J - :pre-condition: au moins 2 bidons + :param *capacites: capacités des bidons disponibles + :return resultat GO: le graphe orienté du W_J + :pre-condition: au moins 2 bidons - :effet de bord: Aucun - """ - nb_bidons = len(capacites) - assert nb_bidons >= 2, "Pas assez de bidons" - resultat = Graphe_Oriente() - # CREATION DES SOMMETS - etats_marginaux = [ - [(contenu,) for contenu in range(1 + capacite)] for capacite in capacites - ] - etats_systeme = produit_cartesien(*etats_marginaux) - for etat in etats_systeme: - resultat.ajoute_sommet(etat) - # CREATION DES TRANSITIONS - for sommet in resultat.sommets: - voisins = list() - # VIDER - for bidon in range(nb_bidons): - voisin = vider(bidon, sommet) - if voisin != sommet and not (voisin in voisins): - voisins.append(voisin) - # REMPLIR - for bidon in range(nb_bidons): - voisin = remplir(bidon, sommet, capacites) - if voisin != sommet and not (voisin in voisins): - voisins.append(voisin) - # TRANSVASER - for origine in range(nb_bidons): - for destination in range(nb_bidons): - if origine != destination: - voisin = transvaser(origine, destination, sommet, capacites) - if voisin != sommet and not (voisin in voisins): - voisins.append(voisin) - # CREATION LISTES ADJACENCE - for voisin in voisins: - resultat.ajoute_arc(sommet, voisin) - return resultat + :effet de bord: Aucun + """ + nb_bidons = len(capacites) + assert nb_bidons >= 2, "Pas assez de bidons" + resultat = Graphe_Oriente() + # CREATION DES SOMMETS + etats_marginaux = [ + [(contenu,) for contenu in range(1 + capacite)] for capacite in capacites + ] + etats_systeme = produit_cartesien(*etats_marginaux) + for etat in etats_systeme: + resultat.ajoute_sommet(etat) + # CREATION DES TRANSITIONS + for sommet in resultat.sommets: + voisins = list() + # VIDER + for bidon in range(nb_bidons): + voisin = vider(bidon, sommet) + if voisin != sommet and not (voisin in voisins): + voisins.append(voisin) + # REMPLIR + for bidon in range(nb_bidons): + voisin = remplir(bidon, sommet, capacites) + if voisin != sommet and not (voisin in voisins): + voisins.append(voisin) + # TRANSVASER + for origine in range(nb_bidons): + for destination in range(nb_bidons): + if origine != destination: + voisin = transvaser(origine, destination, sommet, capacites) + if voisin != sommet and not (voisin in voisins): + voisins.append(voisin) + # CREATION LISTES ADJACENCE + for voisin in voisins: + resultat.ajoute_arc(sommet, voisin) + return resultat def atteindre(quantite, graphe_water_jug, depart=None, plus_court=False): - """ - Résolution du problème pour une quantite donnée + """ + Résolution du problème pour une quantite donnée - :param quantite int: la quantité à mesurer - :param graphe_water_jug GO: le graphe de la situation - :param depart tuple: etat initial, sommet d'origine dans le graphe - (bidons tous vides si depart est None, ie non fourni) - :param plus_court bool: si vrai, seul le(s) plus court(s) chemin(s) - est (sont) retenu(s) + :param quantite int: la quantité à mesurer + :param graphe_water_jug GO: le graphe de la situation + :param depart tuple: etat initial, sommet d'origine dans le graphe + (bidons tous vides si depart est None, ie non fourni) + :param plus_court bool: si vrai, seul le(s) plus court(s) chemin(s) + est (sont) retenu(s) - :return list: la liste des tuples (sommet arrivee, nb d'etapes, ititneraire) ok - """ - if depart is None: - nb_bidons = len(graphe_water_jug.sommets[0]) - depart = tuple([0 for _ in range(nb_bidons)]) - chemins = construire_chemins(graphe_water_jug, depart) - resultat = list() - for sommet in chemins: - if quantite in sommet: - longueur, _ = chemins[sommet] - chemin = reconstruire_chemin_vers(chemins, sommet).pop() - index = len(resultat) - resultat.append((sommet, longueur, chemin)) - while index > 0: - if resultat[index - 1][1] < longueur: - break - else: - resultat[index], resultat[index - 1] = ( - resultat[index - 1], - resultat[index], - ) - index -= 1 - if len(resultat) < 2 or not (plus_court): - return resultat - mini = resultat[0][1] - return [element for element in resultat if element[1] == mini] + :return list: la liste des tuples (sommet arrivee, nb d'etapes, ititneraire) ok + """ + if depart is None: + nb_bidons = len(graphe_water_jug.sommets[0]) + depart = tuple([0 for _ in range(nb_bidons)]) + chemins = construire_chemins(graphe_water_jug, depart) + resultat = list() + for sommet in chemins: + if quantite in sommet: + longueur, _ = chemins[sommet] + chemin = reconstruire_chemin_vers(chemins, sommet).pop() + index = len(resultat) + resultat.append((sommet, longueur, chemin)) + while index > 0: + if resultat[index - 1][1] < longueur: + break + else: + resultat[index], resultat[index - 1] = ( + resultat[index - 1], + resultat[index], + ) + index -= 1 + if len(resultat) < 2 or not (plus_court): + return resultat + mini = resultat[0][1] + return [element for element in resultat if element[1] == mini] def main(): - solutions = atteindre(4, creer_water_jug(3,5)) - - for (sommet_final, nb_etapes, chemin) in solutions: - print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes") - print(affichage_chemin(chemin)) - print("--------------------------------------") + solutions = atteindre(4, creer_water_jug(3, 5)) + + 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.") + 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: - print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes") - print(affichage_chemin(chemin)) - print("--------------------------------------") + for i in range(10): + resolutions = atteindre(i, creer_water_jug(3, 5), None, True) + 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("--------------------------------------") + 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: - print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes") - print(affichage_chemin(chemin)) - print("--------------------------------------") + solution = atteindre(1, creer_water_jug(3, 5, 9), 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("--------------------------------------") if __name__ == "__main__": - import doctest - doctest.testmod(verbose=True) - main() - question1() - question2() - question3() - question4() + import doctest + + doctest.testmod(verbose=True) + main() + question1() + question2() + question3() + question4() diff --git a/graphes/leaudibidon/correction.py b/graphes/leaudibidon/correction.py index fb450ee..fd02100 100644 --- a/graphes/leaudibidon/correction.py +++ b/graphes/leaudibidon/correction.py @@ -1,22 +1,20 @@ def produit_cartesien(*listes): - if not listes: - return [] - if len(listes) == 1: - return listes[0] - if len(listes) == 2: - liste1, liste2 = listes - resultat = list() - for tuple_1 in liste1: - for tuple_2 in liste2: - resultat.append(tuple_1 + tuple_2) - return resultat - liste1, *reste = listes - return produit_cartesien(liste1, produit_cartesien(*reste)) - + if not listes: + return [] + if len(listes) == 1: + return listes[0] + if len(listes) == 2: + liste1, liste2 = listes + resultat = list() + for tuple_1 in liste1: + for tuple_2 in liste2: + resultat.append(tuple_1 + tuple_2) + return resultat + liste1, *reste = 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)) - +liste3 = [(_,) for _ in range(8)] +print(produit_cartesien(liste1, liste2)) diff --git a/graphes/leaudibidon/main.py b/graphes/leaudibidon/main.py index fdff01c..2e9e242 100644 --- a/graphes/leaudibidon/main.py +++ b/graphes/leaudibidon/main.py @@ -1,31 +1,35 @@ class leaudibidon(object): - def __init__(self,capacity): + def __init__(self, capacity): self.capacity = capacity self.quantity = 0 - def fullfill_b5(b5,b3): + def fullfill_b5(b5, b3): b5.quantity = b5.capacity print("Fullfill b5") - def fullfill_b3(b5,b3): + def fullfill_b3(b5, b3): b3.quantity = b3.capacity print("Fullfill b3") - def void_b5(b5,b3): + def void_b5(b5, b3): b5.quantity = 0 print("void b5") - - def void_b3(b5,b3): + def void_b3(b5, b3): b3.quantity = 0 print("void b3") - def transfer_b5_b3(b5,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 - - - def transfer_b3_b5(b5,b3): + 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, + ) diff --git a/graphes/maze/fifo.py b/graphes/maze/fifo.py index 23e1149..45a1344 100644 --- a/graphes/maze/fifo.py +++ b/graphes/maze/fifo.py @@ -2,17 +2,17 @@ class Pile: def __init__(self) -> None: self.element = [] - def empiler(self,element)->None: + def empiler(self, element) -> None: self.element.append(element) - def est_vide(self)->bool: + 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: + def size(self) -> int: return len(self.element) def index(self, k): diff --git a/graphes/maze/lifo.py b/graphes/maze/lifo.py index d9ec861..b075015 100644 --- a/graphes/maze/lifo.py +++ b/graphes/maze/lifo.py @@ -2,7 +2,7 @@ class Queue: def __init__(self) -> None: self.element = [] - def enfiler(self,element): + def enfiler(self, element): self.element.append(element) def est_vide(self): @@ -16,5 +16,5 @@ class Queue: return len(self.element) def index(self, k): - assert self.est_vide() , "La file est vide" + assert self.est_vide(), "La file est vide" return self.element[k] diff --git a/graphes/maze/main.py b/graphes/maze/main.py index 896fc9d..1644c89 100644 --- a/graphes/maze/main.py +++ b/graphes/maze/main.py @@ -1,7 +1,7 @@ import maze_creator as mc -lab = mc.Labyrinth(10,10) -lab.set_start_end((0,0),(100,100)) +lab = mc.Labyrinth(10, 10) +lab.set_start_end((0, 0), (100, 100)) lab.generate_maze() print(lab.__str__()) diff --git a/graphes/maze/maze_creator.py b/graphes/maze/maze_creator.py index 20ef0a2..c148952 100644 --- a/graphes/maze/maze_creator.py +++ b/graphes/maze/maze_creator.py @@ -1,5 +1,6 @@ import random as rnd + class Labyrinth: def __init__(self, rows, cols) -> None: self.rows = rows @@ -20,7 +21,7 @@ class Labyrinth: 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): @@ -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 + ) diff --git a/graphes/maze/test.py b/graphes/maze/test.py index 5568002..f5c9ea7 100644 --- a/graphes/maze/test.py +++ b/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 !") - diff --git a/graphes/monday_homework.py b/graphes/monday_homework.py index b50e4d4..7781965 100644 --- a/graphes/monday_homework.py +++ b/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")) diff --git a/magic_square/TDliste2liste/exercice1.py b/magic_square/TDliste2liste/exercice1.py index f0a9683..5040495 100644 --- a/magic_square/TDliste2liste/exercice1.py +++ b/magic_square/TDliste2liste/exercice1.py @@ -1,4 +1,4 @@ -def appartient(elt,tableau): +def appartient(elt, tableau): for i in tableau: if i == elt: return True @@ -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])) + 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])) diff --git a/magic_square/TDliste2liste/exercice2.py b/magic_square/TDliste2liste/exercice2.py index 2f7708e..b6a2023 100644 --- a/magic_square/TDliste2liste/exercice2.py +++ b/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,7 +16,8 @@ def indice_max(tableau): else: continue + if __name__ == "__main__": - l1 = [0,2,3,4,5,6,7,8,9,90,91,59,1] + l1 = [0, 2, 3, 4, 5, 6, 7, 8, 9, 90, 91, 59, 1] print(max_local(l1)) print(indice_max(l1)) diff --git a/magic_square/TDliste2liste/exercice3.py b/magic_square/TDliste2liste/exercice3.py index 7566bd1..752d100 100644 --- a/magic_square/TDliste2liste/exercice3.py +++ b/magic_square/TDliste2liste/exercice3.py @@ -1,8 +1,11 @@ -def cree_tableau_n_m(n,m): +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_n_m(3, 5)) print(cree_tableau_carre_n(5)) diff --git a/magic_square/TDliste2liste/exercice4.py b/magic_square/TDliste2liste/exercice4.py index 814150f..281129a 100644 --- a/magic_square/TDliste2liste/exercice4.py +++ b/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)) diff --git a/magic_square/TDliste2liste/exercice5.py b/magic_square/TDliste2liste/exercice5.py index 6471d60..a10682a 100644 --- a/magic_square/TDliste2liste/exercice5.py +++ b/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 diff --git a/magic_square/TDliste2liste/exercice6.py b/magic_square/TDliste2liste/exercice6.py index 7881f21..6017e5c 100644 --- a/magic_square/TDliste2liste/exercice6.py +++ b/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))] diff --git a/magic_square/magic_square.py b/magic_square/magic_square.py index cc1d8d4..b6e5dd1 100644 --- a/magic_square/magic_square.py +++ b/magic_square/magic_square.py @@ -1,16 +1,23 @@ from TDliste2liste.exercice6 import diag_1, diag_2, colonne + + def check_diagonale(liste): - return diag1(liste), diag2(liste) + return diag1(liste), diag2(liste) + + def check_colonne(liste): - somme = [] - for i in range(len(liste)): - somme.append(colonne(i,liste)) - return somme + 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 + 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) @@ -42,7 +49,6 @@ def check_all(carre): return all_same -carre1=[[4, 9, 2],\ - [3, 5, 7],\ - [8, 1, 6]] + +carre1 = [[4, 9, 2], [3, 5, 7], [8, 1, 6]] print(check_all(carre1)) diff --git a/magic_square/td_carre_magique.py b/magic_square/td_carre_magique.py index 8ad17c7..54244ab 100644 --- a/magic_square/td_carre_magique.py +++ b/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]] - carre5=[[1, 14, 14, 4],\ - [11, 7, 6, 9],\ - [8, 10, 10, 5],\ - [13, 2, 3, 15]] +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]] + carre5 = [[1, 14, 14, 4], [11, 7, 6, 9], [8, 10, 10, 5], [13, 2, 3, 15]] diff --git a/partition_fusion/code.py b/partition_fusion/code.py index 9356ba9..2958eab 100644 --- a/partition_fusion/code.py +++ b/partition_fusion/code.py @@ -8,9 +8,10 @@ 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] + gauche = tab[debut : milieu + 1] + droite = tab[milieu + 1 : fin + 1] i, j, k = 0, 0, debut while i < len(gauche) and j < len(droite): @@ -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) - diff --git a/partition_fusion/code2.py b/partition_fusion/code2.py index 87796d3..7aa3670 100644 --- a/partition_fusion/code2.py +++ b/partition_fusion/code2.py @@ -1,28 +1,31 @@ from random import shuffle + i = 0 -def fusion(liste_1,liste_2): + + +def fusion(liste_1, liste_2): global i if len(liste_1) == 0: return liste_2 if len(liste_2) == 0: return liste_1 if liste_1[0] <= liste_2[0]: - i+=1 - return [liste_1[0]] + fusion(liste_1[1:],liste_2) - i+=1 - return [liste_2[0]] + fusion(liste_1,liste_2[1:]) + i += 1 + return [liste_1[0]] + fusion(liste_1[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: + if len(liste) <= 1: return liste - i+=1 - millieu = len(liste)//2 + i += 1 + millieu = len(liste) // 2 return fusion(tri_pf(liste[:millieu]), tri_pf(liste[millieu:])) - -test = [23,8,20,10,13,1] -print(test,i) +test = [23, 8, 20, 10, 13, 1] +print(test, i) test = tri_pf(test) -print(test, i ) +print(test, i) diff --git a/partition_fusion/liste.py b/partition_fusion/liste.py index c3e66de..12d52ae 100644 --- a/partition_fusion/liste.py +++ b/partition_fusion/liste.py @@ -7,23 +7,25 @@ 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 ajouter(liste, element): + return (element, liste) + def tete(liste): - assert not(est_vide(liste)), "Liste vide" + assert not (est_vide(liste)), "Liste vide" element, _ = liste return element + def queue(liste): - assert not(est_vide(liste)), "Liste vide" - _,reste = liste + assert not (est_vide(liste)), "Liste vide" + _, reste = liste return reste diff --git a/partition_fusion/partition_fusion.py b/partition_fusion/partition_fusion.py index 8cfbe63..17c6638 100644 --- a/partition_fusion/partition_fusion.py +++ b/partition_fusion/partition_fusion.py @@ -12,16 +12,16 @@ import liste as fifo def taille(liste): a = 0 - while not(fifo.est_vide(liste)): + while not (fifo.est_vide(liste)): liste = fifo.queue(liste) - a+=1 + a += 1 return a + def divise2(liste): n = taille(liste) - droite, gauche = partition(liste,0,n//2) - return droite,gauche - + droite, gauche = partition(liste, 0, n // 2) + return droite, gauche def renverser(liste): @@ -41,30 +41,29 @@ def partition(liste, debut, fin): if fifo.est_vide(current): break current = fifo.queue(current) - + segment_inversé = fifo.creer_liste() for _ in range(fin - debut): if fifo.est_vide(current): break segment_inversé = fifo.ajouter(segment_inversé, fifo.tete(current)) current = fifo.queue(current) - + segment = renverser(segment_inversé) return current, segment -def fusion(gauche,droite): +def fusion(gauche, droite): if fifo.est_vide(gauche): return droite if fifo.est_vide(droite): return gauche - if fifo.tete(gauche)<=fifo.tete(droite): - return fifo.ajouter(fusion(fifo.queue(gauche),droite),fifo.tete(gauche)) + if fifo.tete(gauche) <= fifo.tete(droite): + return fifo.ajouter(fusion(fifo.queue(gauche), droite), fifo.tete(gauche)) else: - return fifo.ajouter(fusion(gauche,fifo.queue(droite)),fifo.tete(droite)) - + return fifo.ajouter(fusion(gauche, fifo.queue(droite)), fifo.tete(droite)) def merge_sort(liste): @@ -72,19 +71,19 @@ def merge_sort(liste): if fifo.est_vide(liste): return liste elif fifo.est_vide(fifo.queue(liste)): - return liste # si elle ne contient que un elt + return liste # si elle ne contient que un elt gauche, droite = divise2(liste) + tri1 = merge_sort(gauche) # recursif + tri2 = merge_sort(droite) # recursif - tri1 = merge_sort(gauche) # recursif - tri2 = merge_sort(droite) # recursif + return fusion(tri1, tri2) - return fusion(tri1,tri2) if __name__ == "__main__": liste = fifo.creer_liste() for i in reversed(range(100)): - liste = fifo.ajouter(liste,i) + liste = fifo.ajouter(liste, i) print(liste) print("Après avoir trié la liste:") diff --git a/perfect_number/main.py b/perfect_number/main.py index f663a4d..72487d1 100644 --- a/perfect_number/main.py +++ b/perfect_number/main.py @@ -1,11 +1,14 @@ import math + + def find_diviseur(number): diviseurs = [] - limit = int(number/2) - for i in range(1,limit): - if number %i == 0: + limit = int(number / 2) + for i in range(1, limit): + if number % i == 0: diviseurs.append(i) return diviseurs + if __name__ == "__main__": print(find_diviseur(15)) diff --git a/pygame/V2/balle/balle.py b/pygame/V2/balle/balle.py index 9630139..e3849db 100755 --- a/pygame/V2/balle/balle.py +++ b/pygame/V2/balle/balle.py @@ -3,39 +3,43 @@ from constantes import * import raquette from math import * + class Balle(object): - + def __init__(self): - self.rayon = 10 - self.xpos = LARGEUR_ECRAN/2 - self.ypos = HAUTEUR_ECRAN/2 - self.xvit =4.5 - self.yvit = 3.0 - - - def deplace(self,raquette): + self.rayon = 10 + self.xpos = LARGEUR_ECRAN / 2 + self.ypos = HAUTEUR_ECRAN / 2 + 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: - self.xvit = - self.xvit + self.xvit = -self.xvit if self.ypos + self.rayon > HAUTEUR_ECRAN or self.ypos - self.rayon < 0: - self.yvit = - self.yvit - - if self.ypos >= HAUTEUR_ECRAN-20: + self.yvit = -self.yvit + + if self.ypos >= HAUTEUR_ECRAN - 20: 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: + self.yvit = -self.yvit + if ( + self.xpos + >= raquette.xpos + raquette.largeur - raquette.largeur / 10 + ): self.xvit = 4.0 self.yvit = 6.0 - - if self.xpos <= raquette.xpos + raquette.largeur/20: + + if self.xpos <= raquette.xpos + raquette.largeur / 20: self.xvit = -4.0 - self.yvit = 6.0 \ No newline at end of file + self.yvit = 6.0 diff --git a/pygame/V2/balle/balle_rebondissante.py b/pygame/V2/balle/balle_rebondissante.py index 7d8add9..76a273e 100755 --- a/pygame/V2/balle/balle_rebondissante.py +++ b/pygame/V2/balle/balle_rebondissante.py @@ -2,13 +2,13 @@ import sys, pygame import balle from constantes import * -pygame.init() #initialisation des modules de pygame +pygame.init() # initialisation des modules de pygame # Creation de la fenetre ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN)) -ecran.fill(BLANC) +ecran.fill(BLANC) -pygame.display.set_caption('Balle rebondissante') +pygame.display.set_caption("Balle rebondissante") clock = pygame.time.Clock() @@ -16,28 +16,27 @@ b1 = balle.Balle() bouge = False -while True: #Demarrage de la boucle infinie - for event in pygame.event.get(): - if event.type == pygame.QUIT: #Evt de sortie de boucle - sys.exit() - elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: - bouge = not bouge - elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: - bouge = not bouge - ecran.fill(BLANC) - - b1.deplace() - b1.affiche(ecran) - pygame.display.update() - - - ecran.fill(BLANC) - if bouge: - b1.deplace() - b1.affiche(ecran) - - pygame.display.update() #rafraichissement - clock.tick(60) - -if __name__ == '__main__': +while True: # Demarrage de la boucle infinie + for event in pygame.event.get(): + if event.type == pygame.QUIT: # Evt de sortie de boucle + sys.exit() + elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: + bouge = not bouge + elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: + bouge = not bouge + ecran.fill(BLANC) + + b1.deplace() + b1.affiche(ecran) + pygame.display.update() + + ecran.fill(BLANC) + if bouge: + b1.deplace() + b1.affiche(ecran) + + pygame.display.update() # rafraichissement + clock.tick(60) + +if __name__ == "__main__": b1 = balle.Balle() diff --git a/pygame/V2/balle/casse_brique.py b/pygame/V2/balle/casse_brique.py index 133afb5..c98deb4 100755 --- a/pygame/V2/balle/casse_brique.py +++ b/pygame/V2/balle/casse_brique.py @@ -1,4 +1,4 @@ -import sys, pygame +import sys, pygame import balle import raquette from constantes import * @@ -6,10 +6,10 @@ from constantes import * pygame.init() # Creation de la fenetre -ecran = pygame.display.set_mode((LARGEUR_ECRAN,HAUTEUR_ECRAN)) +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() @@ -19,25 +19,23 @@ bouge = False bouge_gauche_raquette = False bouge_droite_raquette = False -while True : - for event in pygame.event.get() : - if event.type == pygame.QUIT : +while True: + for event in pygame.event.get(): + if event.type == pygame.QUIT: sys.exit() - elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE : + elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: bouge = not bouge - + if pygame.key.get_pressed()[pygame.K_q]: r1.deplaceGauche() if pygame.key.get_pressed()[pygame.K_d]: r1.deplaceDroite() ecran.fill(BLANC) - - if bouge : + + if bouge: b1.deplace(r1) - - - + b1.deplace(r1) b1.affiche(ecran) r1.affiche(ecran) diff --git a/pygame/V2/balle/constantes.py b/pygame/V2/balle/constantes.py index 7a7aad6..4619cab 100755 --- a/pygame/V2/balle/constantes.py +++ b/pygame/V2/balle/constantes.py @@ -1,6 +1,6 @@ ##########Definitions des constantes # Taille de la fenetre -LARGEUR_ECRAN = 600 +LARGEUR_ECRAN = 600 HAUTEUR_ECRAN = 800 # Couleur BLANC = (255, 255, 255) diff --git a/pygame/V2/balle/raquette.py b/pygame/V2/balle/raquette.py index 9a97fce..2e2bba6 100755 --- a/pygame/V2/balle/raquette.py +++ b/pygame/V2/balle/raquette.py @@ -1,56 +1,59 @@ import pygame from constantes import * + class Raquette: """ - Definie une raquette qui se deplace horizontalement - dans le bas de la fenetre ecran - Attributs : largeur (int defaut 100), - xpos (int defaut LARGEUR_ECRAN//2 - self.largeur//2), - vit (int defaut 6) - L'épaisseur de la raquette est de 10 - Methodes : deplaceGauche, deplaceDroite, affiche - """ + Definie une raquette qui se deplace horizontalement + dans le bas de la fenetre ecran + Attributs : largeur (int defaut 100), + xpos (int defaut LARGEUR_ECRAN//2 - self.largeur//2), + vit (int defaut 6) + L'épaisseur de la raquette est de 10 + Methodes : deplaceGauche, deplaceDroite, affiche + """ def __init__(self): self.largeur = 100 - self.xpos = LARGEUR_ECRAN//2 - self.largeur//2 + self.xpos = LARGEUR_ECRAN // 2 - self.largeur // 2 self.vit = 6 def deplaceGauche(self): """ - Deplace la raquette de vit vers la gauche - Parametres : - self : Raquette - Return : - None - Effet de bord : - Modifie l'attribut xpos en lui enlevant, - si c'est possible la valeur de vit (et met xpos à 0 sinon) - """ + Deplace la raquette de vit vers la gauche + Parametres : + self : Raquette + Return : + None + Effet de bord : + Modifie l'attribut xpos en lui enlevant, + si c'est possible la valeur de vit (et met xpos à 0 sinon) + """ self.xpos -= self.vit if self.xpos < 0: self.xpos = 0 - def deplaceDroite(self): """ - Deplace la raquette de vit vers la droite - Parametres : - self : Raquette - Return : - None - Effet de bord : - Modifie l'attribut xpos en lui ajoutant, - si c'est possible la valeur de vit (et met xpos à - 600-self.largeur sinon sinon) - """ + Deplace la raquette de vit vers la droite + Parametres : + self : Raquette + Return : + None + Effet de bord : + Modifie l'attribut xpos en lui ajoutant, + si c'est possible la valeur de vit (et met xpos à + 600-self.largeur sinon sinon) + """ self.xpos += self.vit if self.xpos > LARGEUR_ECRAN - self.largeur: 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__': - pass + +if __name__ == "__main__": + pass diff --git a/pygame/bouncing_ball/ball.py b/pygame/bouncing_ball/ball.py index ed5f031..55b2041 100644 --- a/pygame/bouncing_ball/ball.py +++ b/pygame/bouncing_ball/ball.py @@ -1,20 +1,21 @@ import sys, pygame import balle + ##########Definitions des constantes # Taille de la fenetre -LARGEUR_ECRAN = 600 +LARGEUR_ECRAN = 600 HAUTEUR_ECRAN = 800 # Couleur BLANC = (255, 255, 255) NOIR = (0, 0, 0) -pygame.init() #initialisation des modules de pygame +pygame.init() # initialisation des modules de pygame # Creation de la fenetre ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN)) -ecran.fill(BLANC) +ecran.fill(BLANC) -pygame.display.set_caption('Balle rebondissante') +pygame.display.set_caption("Balle rebondissante") clock = pygame.time.Clock() @@ -22,21 +23,19 @@ b1 = balle.Balle() bouge = False -while True: #Demarrage de la boucle infinie - for event in pygame.event.get(): - if event.type == pygame.QUIT: #Evt de sortie de boucle - sys.exit() - elif event.type == pygame.MOUSEBUTTONDOWN: - bouge = not bouge - elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: - bouge = not bouge - - - ecran.fill(BLANC) - if bouge: - b1.deplace() - b1.affiche(ecran) - - pygame.display.update() #rafraichissement - clock.tick(60) +while True: # Demarrage de la boucle infinie + for event in pygame.event.get(): + if event.type == pygame.QUIT: # Evt de sortie de boucle + sys.exit() + elif event.type == pygame.MOUSEBUTTONDOWN: + bouge = not bouge + elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: + bouge = not bouge + ecran.fill(BLANC) + if bouge: + b1.deplace() + b1.affiche(ecran) + + pygame.display.update() # rafraichissement + clock.tick(60) diff --git a/pygame/bouncing_ball/balle.py b/pygame/bouncing_ball/balle.py index 6533eab..4bd376a 100644 --- a/pygame/bouncing_ball/balle.py +++ b/pygame/bouncing_ball/balle.py @@ -1,23 +1,24 @@ import pygame -class Balle : - """ - Definie une balle qui se deplace dans la fenetre ecran - Attributs : rayon , xpos , ypos , xvit , yvit - Methodes : deplace , affiche - """ - def __init__ ( self ) : - self.rayon = 10 - self.xpos = 300.0 - self.ypos = 400.0 - self.xvit = 4.5 - self.yvit = 3.0 +class Balle: + """ + Definie une balle qui se deplace dans la fenetre ecran + Attributs : rayon , xpos , ypos , xvit , yvit + Methodes : deplace , affiche + """ - def deplace ( self ) : - self.xpos += self.xvit - self.ypos += self.yvit - if self.xpos + self.rayon > 600 or self.xpos - self.rayon < 0: - self.xvit = - self.xvit - elif self.ypos + self.rayon > 800 or self.ypos - self.rayon < 0: - self.yvit = - self.yvit + def __init__(self): + self.rayon = 10 + self.xpos = 300.0 + self.ypos = 400.0 + self.xvit = 4.5 + self.yvit = 3.0 + + def deplace(self): + self.xpos += self.xvit + self.ypos += self.yvit + if self.xpos + self.rayon > 600 or self.xpos - self.rayon < 0: + self.xvit = -self.xvit + elif self.ypos + self.rayon > 800 or self.ypos - self.rayon < 0: + self.yvit = -self.yvit diff --git a/pygame/bouncing_ball/constantes.py b/pygame/bouncing_ball/constantes.py index a4e8f30..5df050b 100644 --- a/pygame/bouncing_ball/constantes.py +++ b/pygame/bouncing_ball/constantes.py @@ -1,5 +1,4 @@ LARGEUR_ECRAN = 600 HAUTEUR_ECRAN = 800 -BLANC = (255,255,255) - +BLANC = (255, 255, 255) diff --git a/pygame/bouncing_ball/raquette.py b/pygame/bouncing_ball/raquette.py index 718e645..cb85f9e 100644 --- a/pygame/bouncing_ball/raquette.py +++ b/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 - raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur): + if ( + 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) - diff --git a/pygame/bouncing_ball_project/ball.py b/pygame/bouncing_ball_project/ball.py index ed5f031..55b2041 100644 --- a/pygame/bouncing_ball_project/ball.py +++ b/pygame/bouncing_ball_project/ball.py @@ -1,20 +1,21 @@ import sys, pygame import balle + ##########Definitions des constantes # Taille de la fenetre -LARGEUR_ECRAN = 600 +LARGEUR_ECRAN = 600 HAUTEUR_ECRAN = 800 # Couleur BLANC = (255, 255, 255) NOIR = (0, 0, 0) -pygame.init() #initialisation des modules de pygame +pygame.init() # initialisation des modules de pygame # Creation de la fenetre ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN)) -ecran.fill(BLANC) +ecran.fill(BLANC) -pygame.display.set_caption('Balle rebondissante') +pygame.display.set_caption("Balle rebondissante") clock = pygame.time.Clock() @@ -22,21 +23,19 @@ b1 = balle.Balle() bouge = False -while True: #Demarrage de la boucle infinie - for event in pygame.event.get(): - if event.type == pygame.QUIT: #Evt de sortie de boucle - sys.exit() - elif event.type == pygame.MOUSEBUTTONDOWN: - bouge = not bouge - elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: - bouge = not bouge - - - ecran.fill(BLANC) - if bouge: - b1.deplace() - b1.affiche(ecran) - - pygame.display.update() #rafraichissement - clock.tick(60) +while True: # Demarrage de la boucle infinie + for event in pygame.event.get(): + if event.type == pygame.QUIT: # Evt de sortie de boucle + sys.exit() + elif event.type == pygame.MOUSEBUTTONDOWN: + bouge = not bouge + elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE: + bouge = not bouge + ecran.fill(BLANC) + if bouge: + b1.deplace() + b1.affiche(ecran) + + pygame.display.update() # rafraichissement + clock.tick(60) diff --git a/pygame/bouncing_ball_project/balle.py b/pygame/bouncing_ball_project/balle.py index e2c2087..14d990c 100644 --- a/pygame/bouncing_ball_project/balle.py +++ b/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 + ) diff --git a/pygame/bouncing_ball_project/bouncing_ball_game.py b/pygame/bouncing_ball_project/bouncing_ball_game.py index fffe058..cb85f9e 100644 --- a/pygame/bouncing_ball_project/bouncing_ball_game.py +++ b/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 - raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur): + if ( + balle.ypos + balle.rayon >= HAUTEUR_ECRAN - 20 + and raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur + ): balle.yvit = -balle.yvit balle.affiche(ecran) diff --git a/pygame/bouncing_ball_project/constantes.py b/pygame/bouncing_ball_project/constantes.py index a4e8f30..5df050b 100644 --- a/pygame/bouncing_ball_project/constantes.py +++ b/pygame/bouncing_ball_project/constantes.py @@ -1,5 +1,4 @@ LARGEUR_ECRAN = 600 HAUTEUR_ECRAN = 800 -BLANC = (255,255,255) - +BLANC = (255, 255, 255) diff --git a/pygame/bouncing_ball_project/raquette.py b/pygame/bouncing_ball_project/raquette.py index fdd2607..aa23a77 100644 --- a/pygame/bouncing_ball_project/raquette.py +++ b/pygame/bouncing_ball_project/raquette.py @@ -1,12 +1,13 @@ import pygame from constantes import * + class Raquette: """ Définit une raquette qui se déplace horizontalement dans le bas de la fenêtre écran. - Attributs : largeur (int, par défaut 100), - xpos (int, par défaut LARGEUR_ECRAN//2 - largeur//2), + Attributs : largeur (int, par défaut 100), + xpos (int, par défaut LARGEUR_ECRAN//2 - largeur//2), vit (int, par défaut 6) L'épaisseur de la raquette est de 10. Méthodes : deplaceGauche, deplaceDroite, affiche @@ -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__': - pass + +if __name__ == "__main__": + pass diff --git a/pygame/lab_py/main.py b/pygame/lab_py/main.py index d1e52a4..fb401d5 100644 --- a/pygame/lab_py/main.py +++ b/pygame/lab_py/main.py @@ -3,9 +3,9 @@ import random import sys # Paramètres de la grille -CELL_SIZE = 20 # Taille d'une cellule en pixels -COLS = 30 # Nombre de colonnes -ROWS = 30 # Nombre de lignes +CELL_SIZE = 20 # Taille d'une cellule en pixels +COLS = 30 # Nombre de colonnes +ROWS = 30 # Nombre de lignes WIDTH = COLS * CELL_SIZE HEIGHT = ROWS * CELL_SIZE @@ -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): @@ -31,23 +32,29 @@ class Cell: # Remplir la cellule (si visitée) AVANT de dessiner les murs if self.visited: 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']: - pygame.draw.line(surface, WHITE, (x + CELL_SIZE, y), (x + CELL_SIZE, y + CELL_SIZE)) - if self.walls['bottom']: - pygame.draw.line(surface, WHITE, (x + CELL_SIZE, y + CELL_SIZE), (x, y + CELL_SIZE)) - if self.walls['left']: + if self.walls["right"]: + pygame.draw.line( + surface, WHITE, (x + CELL_SIZE, y), (x + CELL_SIZE, y + CELL_SIZE) + ) + 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 = [] @@ -68,9 +75,10 @@ def get_unvisited_neighbors(cell): left = get_cell(i - 1, j) if left and not left.visited: neighbors.append(left) - + 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 - next_cell.walls['left'] = False + current.walls["right"] = False + next_cell.walls["left"] = False elif dx == -1: # Voisin à gauche - current.walls['left'] = False - next_cell.walls['right'] = False + current.walls["left"] = False + next_cell.walls["right"] = False elif dy == 1: # Voisin en bas - current.walls['bottom'] = False - next_cell.walls['top'] = False + current.walls["bottom"] = False + next_cell.walls["top"] = False elif dy == -1: # Voisin en haut - current.walls['top'] = False - next_cell.walls['bottom'] = False + current.walls["top"] = False + next_cell.walls["bottom"] = False + def main(): global grid @@ -99,7 +108,7 @@ def main(): # Création de la grille : une matrice de cellules grid = [[Cell(i, j) for j in range(ROWS)] for i in range(COLS)] - + # Initialisation de l'algorithme DFS current = grid[0][0] # Départ en haut à gauche current.visited = True @@ -143,12 +152,12 @@ def main(): x = current.i * CELL_SIZE y = current.j * CELL_SIZE pygame.draw.rect(screen, GREEN, (x, y, CELL_SIZE, CELL_SIZE)) - + pygame.display.flip() pygame.quit() sys.exit() -if __name__ == '__main__': - main() +if __name__ == "__main__": + main() diff --git a/recursivite/TD1.py b/recursivite/TD1.py index efa8fb3..d923ef5 100644 --- a/recursivite/TD1.py +++ b/recursivite/TD1.py @@ -2,27 +2,35 @@ def factorielle(number: int): if number == 0: return 1 else: - return number * factorielle(number-1) + return number * factorielle(number - 1) + def modulo(a, b): - if b-a < 0: + if b - a < 0: return b elif b == 0: return b else: - return modulo(a,b-a) + return modulo(a, b - a) + + def somme(n): if n == 0: return n else: - return(n+somme(n-1)) -def init_quotient(a,b): + return n + somme(n - 1) + + +def init_quotient(a, b): i = 0 - return (quotient(a,b,i)) -def quotient(a,b,i): - if b == 0 or b-a < 0: + 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)) + +print(init_quotient(6, 18)) diff --git a/recursivite/exercice_MJoannic/dichotomie/iteratif/main.py b/recursivite/exercice_MJoannic/dichotomie/iteratif/main.py index 182b524..332564c 100644 --- a/recursivite/exercice_MJoannic/dichotomie/iteratif/main.py +++ b/recursivite/exercice_MJoannic/dichotomie/iteratif/main.py @@ -1,6 +1,7 @@ from sort_list import sort_list -def dichotomie(liste: list, element: any,bypass_sorting = False)->bool: + +def dichotomie(liste: list, element: any, bypass_sorting=False) -> bool: """This function return return True if element is in liste False else Args: @@ -12,18 +13,20 @@ 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 + N, start, find, i = len(liste) - 1, 0, False, 0 end = N while (find != True) and (start <= end): - middle = (start + end)//2 + middle = (start + end) // 2 if liste[middle] == element: find = True elif element > liste[middle]: - start = middle+1 + start = middle + 1 else: end = middle - 1 return find diff --git a/recursivite/exercice_MJoannic/dichotomie/iteratif/tester.py b/recursivite/exercice_MJoannic/dichotomie/iteratif/tester.py index 181d0be..649626d 100644 --- a/recursivite/exercice_MJoannic/dichotomie/iteratif/tester.py +++ b/recursivite/exercice_MJoannic/dichotomie/iteratif/tester.py @@ -1,56 +1,84 @@ from main import dichotomie + + def tester(): - liste1 = [1,2,3,4,5,6,7,8,9,10] + liste1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] liste2 = liste1[:-1] - liste3 = [7,4,1,8,5,2,9,6,3,0] - liste3_2 = [7,7,7,7,7,7,7,8] + liste3 = [7, 4, 1, 8, 5, 2, 9, 6, 3, 0] + liste3_2 = [7, 7, 7, 7, 7, 7, 7, 8] liste4 = [] 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.") - liste9 = [i for i in range(1,100000)] + 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." + ) + 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 dichotomie(liste4, 0) == False, "Test échoué : Liste vide, 0 ne devrait pas être dans liste4" + assert ( + 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 dichotomie(liste9, 0,True) == False, "Test échoué : 5 ne devrait pas être dans liste9"# bypass = True because sorting_list is very slow + assert ( + 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__': - tester() \ No newline at end of file +if __name__ == "__main__": + tester() diff --git a/recursivite/exercice_MJoannic/dichotomie/recursif/correction/V1.py b/recursivite/exercice_MJoannic/dichotomie/recursif/correction/V1.py index 4a15733..a11e194 100644 --- a/recursivite/exercice_MJoannic/dichotomie/recursif/correction/V1.py +++ b/recursivite/exercice_MJoannic/dichotomie/recursif/correction/V1.py @@ -1,28 +1,31 @@ from typing import Any -def est_triee(liste: list)->bool: +def est_triee(liste: list) -> bool: if len(liste) <= 1: return True index = 0 - while (index < len(liste) - 1) and (liste[index]<=liste[index + 1]): - index+=1 - return index>= len(liste) - 1 + while (index < len(liste) - 1) and (liste[index] <= liste[index + 1]): + index += 1 + return index >= len(liste) - 1 -def search(liste:list, element:Any): + +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 else: - pivot = liste[len(liste)//2] + pivot = liste[len(liste) // 2] if pivot == element: return True if element < pivot: - return aux(liste[len(liste)//2], element) - return aux(liste[len(liste)//3 + 1:], element) - return aux(liste,element) + return aux(liste[len(liste) // 2], element) + return aux(liste[len(liste) // 3 + 1 :], element) + + return aux(liste, element) -print(search([1,2,3],2)) +print(search([1, 2, 3], 2)) diff --git a/recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/main.py b/recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/main.py index ce0c9f4..c7bfede 100644 --- a/recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/main.py +++ b/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 diff --git a/recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/tester.py b/recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/tester.py index c68774e..3f0c5df 100644 --- a/recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/tester.py +++ b/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" + print(dichotomie(liste4, 1)) + 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() diff --git a/recursivite/exercice_MJoannic/dichotomie/recursif/myself/main.py b/recursivite/exercice_MJoannic/dichotomie/recursif/myself/main.py index 378bae3..04d2256 100644 --- a/recursivite/exercice_MJoannic/dichotomie/recursif/myself/main.py +++ b/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 diff --git a/recursivite/exercice_MJoannic/dichotomie/recursif/myself/tester.py b/recursivite/exercice_MJoannic/dichotomie/recursif/myself/tester.py index bb94c37..f90317c 100644 --- a/recursivite/exercice_MJoannic/dichotomie/recursif/myself/tester.py +++ b/recursivite/exercice_MJoannic/dichotomie/recursif/myself/tester.py @@ -1,78 +1,106 @@ from main import dichotomie + + def tester(): - liste1 = [1,2,3,4,5,6,7,8,9,10] + liste1 = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10] liste2 = liste1[:-1] - liste3 = [7,4,1,8,5,2,9,6,3,0] - liste3_2 = [7,7,7,7,7,7,7,8] + liste3 = [7, 4, 1, 8, 5, 2, 9, 6, 3, 0] + liste3_2 = [7, 7, 7, 7, 7, 7, 7, 8] liste4 = [] 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.") - liste9 = [i for i in range(1,100000)] - + 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." + ) + 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() diff --git a/recursivite/exercice_MJoannic/palindrom.py b/recursivite/exercice_MJoannic/palindrom.py index 7227bc0..f7a248a 100644 --- a/recursivite/exercice_MJoannic/palindrom.py +++ b/recursivite/exercice_MJoannic/palindrom.py @@ -1,4 +1,4 @@ -def is_palindrom(word)->bool: +def is_palindrom(word) -> bool: word = list(word) if len(word) < 2: return True @@ -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(" ", ""))) diff --git a/recursivite/exercice_MJoannic/sqrt/correction/main.py b/recursivite/exercice_MJoannic/sqrt/correction/main.py index 6f454e0..94a7320 100644 --- a/recursivite/exercice_MJoannic/sqrt/correction/main.py +++ b/recursivite/exercice_MJoannic/sqrt/correction/main.py @@ -1,41 +1,40 @@ def racine(n): def aux(gauche, droite): - if gauche > droite: return droite - + milieu = (gauche + droite) // 2 - + if milieu * milieu == n: return milieu - + elif milieu * milieu > n: return aux(gauche, milieu - 1) - + else: return aux(milieu + 1, droite) - return aux(0, n) + return aux(0, n) def racine_decimale(n, precision=1e-6): def aux(gauche, droite): milieu = (gauche + droite) / 2 - + if droite - gauche < precision: return milieu - + if milieu * milieu == n: return milieu - + elif milieu * milieu < n: return aux(milieu, droite) - + else: return aux(gauche, milieu) - + partie_entiere = racine(n) - + return aux(partie_entiere, partie_entiere + 1) diff --git a/recursivite/exercice_MJoannic/sqrt/main.py b/recursivite/exercice_MJoannic/sqrt/main.py index 6e8c921..bb03d29 100644 --- a/recursivite/exercice_MJoannic/sqrt/main.py +++ b/recursivite/exercice_MJoannic/sqrt/main.py @@ -2,9 +2,9 @@ def racine_raphson(number: float, precision: float) -> float: assert number > 0, "La racine du nombre n'est pas réelle." - y = (number / 3)+ 1 + y = (number / 3) + 1 diff = precision + 1 - + while diff > precision: y_next = (y + number / y) / 2.0 diff = abs(y_next - y) @@ -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) + 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,9 +68,8 @@ 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 - print(racine_dich(0)) # Retourne 0 - print(racine_dich(1)) # Retourne 1 \ No newline at end of file + print(racine_dich(0)) # Retourne 0 + print(racine_dich(1)) # Retourne 1 diff --git a/trees/genealogie/genealogie.py b/trees/genealogie/genealogie.py index 76af43e..7b2521a 100644 --- a/trees/genealogie/genealogie.py +++ b/trees/genealogie/genealogie.py @@ -119,12 +119,14 @@ class Arbre(object): return resultat return Arbre() - def ajouter(self,elt): + def ajouter(self, elt): if self.est_vide(): return Arbre(racine=elt) else: - return Arbre(elt,self) - def enlever(self,elt): + return Arbre(elt, self) + + def enlever(self, elt): pass + def display(self): pass diff --git a/trees/qdj.py b/trees/qdj.py index 97cb51f..4e3d8d8 100644 --- a/trees/qdj.py +++ b/trees/qdj.py @@ -4,10 +4,10 @@ def calcul_taille(arbre, sommet): while reste: if arbre[sommet].voisin_gauche(): sommet = arbre[sommet].voisin_gauche() - i+=1 + i += 1 elif arbre[sommet].voisin_droite(): sommet = arbre[sommet].voisin_droite() - i+=1 + i += 1 return i @@ -15,11 +15,11 @@ def correction(arbre): if arbre.est_vide(): return 0 else: - return 1+correction(arbre.gauche()) + correction(arbre.droite()) + return 1 + correction(arbre.gauche()) + correction(arbre.droite()) def hauteur(arbre): if arbre.est_vide(): return -1 else: - return max([arbre.droite(),arbre.gauche()]) + return max([arbre.droite(), arbre.gauche()]) diff --git a/python/bitab.py b/turing/bitab.py similarity index 100% rename from python/bitab.py rename to turing/bitab.py diff --git a/turing/machine.py b/turing/machine.py index fa64663..536faef 100644 --- a/turing/machine.py +++ b/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) - pointer = ' ' * self.head + '^' - return f'{tape_str}\n{pointer}' + tape_str = "".join(self.tape) + pointer = " " * self.head + "^" + 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': { - '1': ('1', 'd', 'init'), - '0': ('0', 'd', 'init'), - '•': ('1', 'g', 'end') # ajoute un 1 à la fin - } + "init": {"1": ("1", "d", "init"), "0": ("0", "d", "init"), "•": ("1", "g", "end")} } -tm = TuringMachine(transitions, initial_state='init', final_state='end') +tm = TuringMachine(transitions, initial_state="init", final_state="end") tm.run("1011") - diff --git a/turing/mc.py b/turing/mc.py index 025731a..2858900 100644 --- a/turing/mc.py +++ b/turing/mc.py @@ -15,3 +15,5 @@ class Configuration: if __name__ == "__main__": ruban = Ta + +class Machine: