spectre/cours
1
0
Fork 0
mirror of https://github.com/Fare-spec/cours.git synced 2025-12-07 10:50:36 +00:00
Code Issues Packages Projects Releases Wiki Activity

formatte file

Browse Source
This commit is contained in:
Spectre
2025-04-01 14:28:43 +02:00
parent f2ae2cbc13
commit e03e5458aa
77 changed files with 1231 additions and 945 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
Dijkstra/algo.py
View File

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

5
Partie2/Eleve/Projet/control.py
View File

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

7
TDliste2liste/exercice1.py
View File

@@ -1,4 +1,4 @@
def appartient(elt,tableau): def appartient(elt, tableau):
for i in tableau: for i in tableau:
if i == elt: if i == elt:
return True return True
@@ -6,6 +6,7 @@ def appartient(elt,tableau):
continue continue
return False return False
if __name__ == "__main__": if __name__ == "__main__":
print(appartient(5,[1,2,3,4,5,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])) print(appartient(5, [1, 2, 3, 4, 6, 7, 8, 9, 10]))

4
TDliste2liste/exercice2.py
View File

@@ -7,6 +7,7 @@ def max_local(tableau):
continue continue
return maximum return maximum
def indice_max(tableau): def indice_max(tableau):
maximum = max_local(tableau) maximum = max_local(tableau)
for i in range(len(tableau)): for i in range(len(tableau)):
@@ -15,7 +16,8 @@ def indice_max(tableau):
else: else:
continue continue
if __name__ == "__main__": 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(max_local(l1))
print(indice_max(l1)) print(indice_max(l1))

7
TDliste2liste/exercice3.py
View File

@@ -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)] return [[0 for _ in range(m)] for _ in range(n)]
def cree_tableau_carre_n(n): def cree_tableau_carre_n(n):
return [[0 for _ in range(n)] for _ in range(n)] return [[0 for _ in range(n)] for _ in range(n)]
if __name__ == "__main__": if __name__ == "__main__":
print(cree_tableau_n_m(3,5)) print(cree_tableau_n_m(3, 5))
print(cree_tableau_carre_n(5)) print(cree_tableau_carre_n(5))

3
TDliste2liste/exercice4.py
View File

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

5
TDliste2liste/exercice5.py
View File

@@ -2,8 +2,11 @@ def transpose(carre):
n = len(carre) # Nombre de lignes (ou colonnes, car c'est une matrice carrée) 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)] return [[carre[j][i] for j in range(n)] for i in range(n)]
def transpose_en_place(carre): def transpose_en_place(carre):
n = len(carre) # Nombre de lignes (ou colonnes) n = len(carre) # Nombre de lignes (ou colonnes)
for i in range(n): 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 carre[i][j], carre[j][i] = carre[j][i], carre[i][j] # Échange des éléments

2
TDliste2liste/exercice6.py
View File

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

125
casse-brique/main.py
View File

@@ -13,8 +13,8 @@ SCREEN_HEIGHT = 720
# Définition des couleurs (R, G, B) # Définition des couleurs (R, G, B)
BLACK = (0, 0, 0) BLACK = (0, 0, 0)
WHITE = (255, 255, 255) WHITE = (255, 255, 255)
BLUE = (0, 0, 255) BLUE = (0, 0, 255)
RED = (255, 0, 0) RED = (255, 0, 0)
# Création de la fenêtre de jeu # Création de la fenêtre de jeu
screen = pygame.display.set_mode((SCREEN_WIDTH, SCREEN_HEIGHT)) 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() clock = pygame.time.Clock()
FPS = 100 FPS = 100
# Fonction d'affichage du menu de démarrage # Fonction d'affichage du menu de démarrage
def show_menu(): def show_menu():
menu_running = True menu_running = True
@@ -32,22 +33,24 @@ def show_menu():
button_height = 50 button_height = 50
button_rect = pygame.Rect(0, 0, button_width, button_height) button_rect = pygame.Rect(0, 0, button_width, button_height)
button_rect.center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2) button_rect.center = (SCREEN_WIDTH // 2, SCREEN_HEIGHT // 2)
while menu_running: while menu_running:
clock.tick(FPS) clock.tick(FPS)
screen.fill(BLACK) screen.fill(BLACK)
# Affichage du titre # Affichage du titre
title_surface = title_font.render("Casse-Brique", True, WHITE) 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) screen.blit(title_surface, title_rect)
# Dessiner le bouton "Jouer" # Dessiner le bouton "Jouer"
pygame.draw.rect(screen, BLUE, button_rect) pygame.draw.rect(screen, BLUE, button_rect)
button_text = button_font.render("Jouer", True, WHITE) button_text = button_font.render("Jouer", True, WHITE)
button_text_rect = button_text.get_rect(center=button_rect.center) button_text_rect = button_text.get_rect(center=button_rect.center)
screen.blit(button_text, button_text_rect) screen.blit(button_text, button_text_rect)
# Gestion des événements du menu # Gestion des événements du menu
for event in pygame.event.get(): for event in pygame.event.get():
if event.type == pygame.QUIT: if event.type == pygame.QUIT:
@@ -57,32 +60,35 @@ def show_menu():
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
if button_rect.collidepoint(event.pos): if button_rect.collidepoint(event.pos):
menu_running = False menu_running = False
pygame.display.flip() pygame.display.flip()
# Fonction principale du jeu # Fonction principale du jeu
def game_loop(): def game_loop():
# Paramètres de la raquette # Paramètres de la raquette
PADDLE_WIDTH = 100 PADDLE_WIDTH = 100
PADDLE_HEIGHT = 15 PADDLE_HEIGHT = 15
paddle_x = (SCREEN_WIDTH - PADDLE_WIDTH) / 2 # centré horizontalement 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 paddle_speed = 7
# Paramètres de la balle # Paramètres de la balle
ball_radius = 10 ball_radius = 10
# Liste de balles (initialement une seule) # Liste de balles (initialement une seule)
balls = [{ balls = [
'x': SCREEN_WIDTH / 2, {
'y': SCREEN_HEIGHT / 2, "x": SCREEN_WIDTH / 2,
'radius': ball_radius, "y": SCREEN_HEIGHT / 2,
'speed_x': 9 * random.choice([-1, 1]), "radius": ball_radius,
'speed_y': -9 "speed_x": 9 * random.choice([-1, 1]),
}] "speed_y": -9,
}
]
# Paramètres des briques # Paramètres des briques
BRICK_ROWS = 5 # nombre de lignes de briques BRICK_ROWS = 5 # nombre de lignes de briques
BRICK_COLUMNS = 10 # nombre de colonnes de briques BRICK_COLUMNS = 10 # nombre de colonnes de briques
BRICK_WIDTH = SCREEN_WIDTH // BRICK_COLUMNS BRICK_WIDTH = SCREEN_WIDTH // BRICK_COLUMNS
BRICK_HEIGHT = 20 BRICK_HEIGHT = 20
brick_padding = 5 brick_padding = 5
@@ -94,7 +100,9 @@ def game_loop():
for col in range(BRICK_COLUMNS): for col in range(BRICK_COLUMNS):
brick_x = col * BRICK_WIDTH + brick_padding brick_x = col * BRICK_WIDTH + brick_padding
brick_y = row * (BRICK_HEIGHT + brick_padding) + 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) brick_row.append(brick_rect)
bricks.append(brick_row) 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 # On cherche une balle qui descend (speed_y > 0), sinon on prend la première balle
target_ball = None target_ball = None
for ball in balls: for ball in balls:
if ball['speed_y'] > 0: if ball["speed_y"] > 0:
target_ball = ball target_ball = ball
break break
if target_ball is None: if target_ball is None:
@@ -120,9 +128,9 @@ def game_loop():
# Calcul du centre de la raquette # Calcul du centre de la raquette
paddle_center = paddle_x + PADDLE_WIDTH / 2 paddle_center = paddle_x + PADDLE_WIDTH / 2
# Si le centre est trop à gauche ou à droite de la balle cible, on déplace la raquette # 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 paddle_x += paddle_speed
elif paddle_center > target_ball['x'] + 5: elif paddle_center > target_ball["x"] + 5:
paddle_x -= paddle_speed paddle_x -= paddle_speed
# Limiter la raquette à l'intérieur de l'écran # Limiter la raquette à l'intérieur de l'écran
@@ -135,31 +143,40 @@ def game_loop():
# Mise à jour de la position des balles # Mise à jour de la position des balles
for ball in balls: for ball in balls:
ball['x'] += ball['speed_x'] ball["x"] += ball["speed_x"]
ball['y'] += ball['speed_y'] ball["y"] += ball["speed_y"]
# Collision avec les murs latéraux # Collision avec les murs latéraux
if ball['x'] - ball['radius'] <= 0 or ball['x'] + ball['radius'] >= SCREEN_WIDTH: if (
ball['speed_x'] *= -1 ball["x"] - ball["radius"] <= 0
or ball["x"] + ball["radius"] >= SCREEN_WIDTH
):
ball["speed_x"] *= -1
# Collision avec le haut de l'écran # Collision avec le haut de l'écran
if ball['y'] - ball['radius'] <= 0: if ball["y"] - ball["radius"] <= 0:
ball['speed_y'] *= -1 ball["speed_y"] *= -1
# Création du rectangle de la balle pour la détection des collisions # Création du rectangle de la balle pour la détection des collisions
ball_rect = pygame.Rect(ball['x'] - ball['radius'], ball['y'] - ball['radius'], ball_rect = pygame.Rect(
ball['radius'] * 2, ball['radius'] * 2) ball["x"] - ball["radius"],
ball["y"] - ball["radius"],
ball["radius"] * 2,
ball["radius"] * 2,
)
# Collision entre la balle et la raquette (uniquement si la balle descend) # Collision entre la balle et la raquette (uniquement si la balle descend)
if ball_rect.colliderect(paddle_rect) and ball['speed_y'] > 0: if ball_rect.colliderect(paddle_rect) and ball["speed_y"] > 0:
ball['speed_y'] *= -1 # Inversion de la vitesse verticale ball["speed_y"] *= -1 # Inversion de la vitesse verticale
offset = (ball['x'] - (paddle_x + PADDLE_WIDTH / 2)) / (PADDLE_WIDTH / 2) offset = (ball["x"] - (paddle_x + PADDLE_WIDTH / 2)) / (
ball['speed_x'] = 4 * offset PADDLE_WIDTH / 2
)
ball["speed_x"] = 4 * offset
# Création d'une nouvelle balle lors de la collision # Création d'une nouvelle balle lors de la collision
new_ball = ball.copy() new_ball = ball.copy()
new_ball['speed_x'] *= -1 new_ball["speed_x"] *= -1
new_ball['speed_x'] += random.choice([-1, 1]) new_ball["speed_x"] += random.choice([-1, 1])
nouvelles_balles.append(new_ball) nouvelles_balles.append(new_ball)
# Collision entre la balle et les briques # Collision entre la balle et les briques
@@ -168,7 +185,7 @@ def game_loop():
for brick in row: for brick in row:
if brick and ball_rect.colliderect(brick): if brick and ball_rect.colliderect(brick):
hit_brick = brick hit_brick = brick
ball['speed_y'] *= -1 # Inversion de la vitesse verticale ball["speed_y"] *= -1 # Inversion de la vitesse verticale
break break
if hit_brick: if hit_brick:
row[row.index(hit_brick)] = None row[row.index(hit_brick)] = None
@@ -180,27 +197,33 @@ def game_loop():
# Gestion des collisions entre balles # Gestion des collisions entre balles
for i in range(len(balls)): for i in range(len(balls)):
for j in range(i + 1, len(balls)): for j in range(i + 1, len(balls)):
dx = balls[i]['x'] - balls[j]['x'] dx = balls[i]["x"] - balls[j]["x"]
dy = balls[i]['y'] - balls[j]['y'] dy = balls[i]["y"] - balls[j]["y"]
distance = math.sqrt(dx * dx + dy * dy) 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 # Échange des vitesses pour simuler une collision élastique
balls[i]['speed_x'], balls[j]['speed_x'] = balls[j]['speed_x'], balls[i]['speed_x'] balls[i]["speed_x"], balls[j]["speed_x"] = (
balls[i]['speed_y'], balls[j]['speed_y'] = balls[j]['speed_y'], balls[i]['speed_y'] balls[j]["speed_x"],
balls[i]["speed_x"],
)
balls[i]["speed_y"], balls[j]["speed_y"] = (
balls[j]["speed_y"],
balls[i]["speed_y"],
)
# Ajustement des positions pour éviter la superposition # 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: if distance != 0:
nx = dx / distance nx = dx / distance
ny = dy / distance ny = dy / distance
else: else:
nx, ny = 1, 0 nx, ny = 1, 0
balls[i]['x'] += nx * overlap / 2 balls[i]["x"] += nx * overlap / 2
balls[i]['y'] += ny * overlap / 2 balls[i]["y"] += ny * overlap / 2
balls[j]['x'] -= nx * overlap / 2 balls[j]["x"] -= nx * overlap / 2
balls[j]['y'] -= ny * overlap / 2 balls[j]["y"] -= ny * overlap / 2
# Suppression des balles qui sortent par le bas de l'écran # 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: if not balls:
print("Game Over!") print("Game Over!")
running = False running = False
@@ -216,15 +239,17 @@ def game_loop():
# Dessiner les balles # Dessiner les balles
for ball in balls: 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.display.flip()
pygame.quit() pygame.quit()
sys.exit() sys.exit()
# Programme principal # Programme principal
if __name__ == "__main__": if __name__ == "__main__":
show_menu() # Afficher le menu de démarrage show_menu() # Afficher le menu de démarrage
game_loop() # Lancer le jeu game_loop() # Lancer le jeu

4
cesar/chiffrement.py
View File

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

14
crypto/algo.py
View File

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

21
ensembles_dynamiques/TP/_collection.py
View File

@@ -13,6 +13,7 @@
# Un ensemble est une collection d'éléments, d'occurence unique. # Un ensemble est une collection d'éléments, d'occurence unique.
# Les fonctions sont implémentées dans le paradigme fonctionnel. # Les fonctions sont implémentées dans le paradigme fonctionnel.
def initialiser_ensemble(): def initialiser_ensemble():
""" """
Construit un ensemble vide. Construit un ensemble vide.
@@ -26,11 +27,12 @@ def initialiser_ensemble():
Pré-condition : Pré-condition :
- aucune - aucune
Effet de bord Effet de bord
- aucune - aucune
""" """
return set() return set()
def est_ensemble_vide(ensemble): def est_ensemble_vide(ensemble):
""" """
Teste si l'ensemble est vide. Teste si l'ensemble est vide.
@@ -46,6 +48,7 @@ def est_ensemble_vide(ensemble):
""" """
return len(ensemble) == 0 return len(ensemble) == 0
def copier_ensemble(ensemble): def copier_ensemble(ensemble):
""" """
Construit la copie d'un ensemble. Construit la copie d'un ensemble.
@@ -67,6 +70,7 @@ def copier_ensemble(ensemble):
resultat.add(_) resultat.add(_)
return resultat return resultat
def ajouter(ensemble, element): def ajouter(ensemble, element):
""" """
Ajoute un element à la copie d'un ensemble Ajoute un element à la copie d'un ensemble
@@ -88,10 +92,11 @@ def ajouter(ensemble, element):
resultat.add(element) resultat.add(element)
return resultat return resultat
def supprimer(ensemble, element): def supprimer(ensemble, element):
""" """
Construire une copie de l'ensemble privé d'un élément. 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. alors une copie intégrale est renvoyée.
Paramètres : Paramètres :
@@ -103,11 +108,12 @@ def supprimer(ensemble, element):
""" """
resultat = initialiser_ensemble() resultat = initialiser_ensemble()
for _ in ensemble: for _ in ensemble:
if not(_ == element): if not (_ == element):
resultat = ajouter(resultat, _) resultat = ajouter(resultat, _)
return 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 Construit la sous-collection constituée des éléments d'un ensemble
dont la clé satisfait un critère donné. 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, _) resultat = ajouter(resultat, _)
return resultat return resultat
def supprimer_critere(ensemble, cle, critere): 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é. dont la clé satisfait le critère donné.
Paramètres : Paramètres :
@@ -157,9 +164,10 @@ def supprimer_critere(ensemble, cle, critere):
resultat = supprimer(resultat, _) resultat = supprimer(resultat, _)
return resultat return resultat
def lister(ensemble, affichage=print): 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. en formattant chaque élément selon la fonction d'affichage fournie.
Paramètres : Paramètres :
@@ -180,6 +188,5 @@ def lister(ensemble, affichage=print):
return None return None
if __name__ == "__main__": if __name__ == "__main__":
pass pass

20
ensembles_dynamiques/TP/_collection_list.py
View File

@@ -13,6 +13,7 @@
# Un ensemble est une collection d'éléments, d'occurence unique. # Un ensemble est une collection d'éléments, d'occurence unique.
# Les fonctions sont implémentées dans le paradigme fonctionnel. # Les fonctions sont implémentées dans le paradigme fonctionnel.
def initialiser_ensemble(): def initialiser_ensemble():
""" """
Construit un ensemble vide. Construit un ensemble vide.
@@ -31,6 +32,7 @@ def initialiser_ensemble():
""" """
return list() return list()
def est_ensemble_vide(ensemble): def est_ensemble_vide(ensemble):
""" """
Teste si l'ensemble est vide. Teste si l'ensemble est vide.
@@ -46,6 +48,7 @@ def est_ensemble_vide(ensemble):
""" """
return len(ensemble) == 0 return len(ensemble) == 0
def copier_ensemble(ensemble): def copier_ensemble(ensemble):
""" """
Construit la copie d'un ensemble. Construit la copie d'un ensemble.
@@ -64,6 +67,7 @@ def copier_ensemble(ensemble):
""" """
return ensemble[:] return ensemble[:]
def ajouter(ensemble, element): def ajouter(ensemble, element):
""" """
Ajoute un element à la copie d'un ensemble Ajoute un element à la copie d'un ensemble
@@ -85,10 +89,11 @@ def ajouter(ensemble, element):
copie.append(element) copie.append(element)
return copie return copie
def supprimer(ensemble, element): def supprimer(ensemble, element):
""" """
Construire une copie de l'ensemble privé d'un élément. 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. alors une copie intégrale est renvoyée.
Paramètres : Paramètres :
@@ -101,7 +106,8 @@ def supprimer(ensemble, element):
resultat = ensemble[:] resultat = ensemble[:]
return resultat.remove(element) 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 Construit la sous-collection constituée des éléments d'un ensemble
dont la clé satisfait un critère donné. 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)] return [element for element in ensemble if critere(element, cle)]
def supprimer_critere(ensemble, cle, critere): 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é. dont la clé satisfait le critère donné.
Paramètres : Paramètres :
@@ -141,11 +148,12 @@ def supprimer_critere(ensemble, cle, critere):
Effet de bord : Effet de bord :
- aucun - 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): 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. en formattant chaque élément selon la fonction d'affichage fournie.
Paramètres : Paramètres :
@@ -163,5 +171,7 @@ def lister(ensemble, affichage=print):
""" """
for item in ensemble: for item in ensemble:
affichage(item) affichage(item)
if __name__ == "__main__": if __name__ == "__main__":
pass pass

33
ensembles_dynamiques/TP/_sommets.py
View File

@@ -15,6 +15,7 @@
# - altitude : INT, altitude en m # - altitude : INT, altitude en m
# - massif : STR # - massif : STR
def creer_sommet(nom, altitude, massif): def creer_sommet(nom, altitude, massif):
""" """
Construit le tuple sommet. Construit le tuple sommet.
@@ -30,11 +31,12 @@ def creer_sommet(nom, altitude, massif):
Pré-condition : Pré-condition :
- aucune (programmation défensive à envisager) - aucune (programmation défensive à envisager)
Effet de bord : Effet de bord :
- aucun - aucun
""" """
return (nom, altitude, massif) return (nom, altitude, massif)
def altitude_en_m(altitude): def altitude_en_m(altitude):
""" """
Conversion de l'altitude en entier ("2 062 m" -> 2062) Conversion de l'altitude en entier ("2 062 m" -> 2062)
@@ -51,18 +53,19 @@ def altitude_en_m(altitude):
Effet de bord : Effet de bord :
- aucun - aucun
""" """
tmp = '' tmp = ""
for symbole in altitude: for symbole in altitude:
if not(symbole in ' m'): if not (symbole in " m"):
tmp += symbole tmp += symbole
return int(tmp) return int(tmp)
def creer_sommet_csv(ligne, massif): def creer_sommet_csv(ligne, massif):
""" """
Construit un sommet à partir d'une ligne du fichier csv. Construit un sommet à partir d'une ligne du fichier csv.
Paramètres : Paramètres :
- ligne : STR, ligne du fichier csv - ligne : STR, ligne du fichier csv
- massif : STR, basename du fichier contenant la ligne - massif : STR, basename du fichier contenant la ligne
Résultat : Résultat :
@@ -74,9 +77,10 @@ def creer_sommet_csv(ligne, massif):
Effet de bord : Effet de bord :
- aucun - aucun
""" """
nom, alt = ligne.rstrip().split(',') nom, alt = ligne.rstrip().split(",")
return creer_sommet(nom, altitude_en_m(alt), massif) return creer_sommet(nom, altitude_en_m(alt), massif)
def afficher(sommet): def afficher(sommet):
""" """
Affichage formatté du sommet. Affichage formatté du sommet.
@@ -94,9 +98,10 @@ def afficher(sommet):
- Affichage sur la sortie standard - Affichage sur la sortie standard
""" """
nom, altitude, massif = sommet 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 return None
def nom(sommet): def nom(sommet):
""" """
Consulte le nom d'un sommet Consulte le nom d'un sommet
@@ -111,10 +116,11 @@ def nom(sommet):
- aucune - aucune
Effet de bord : Effet de bord :
- aucun - aucun
""" """
return sommet[0] return sommet[0]
def altitude(sommet): def altitude(sommet):
""" """
Consulte l'altitude d'un sommet Consulte l'altitude d'un sommet
@@ -129,10 +135,11 @@ def altitude(sommet):
- aucune - aucune
Effet de bord : Effet de bord :
- aucun - aucun
""" """
return sommet[1] return sommet[1]
def massif(sommet): def massif(sommet):
""" """
Consulte le massif d'un sommet Consulte le massif d'un sommet
@@ -147,10 +154,11 @@ def massif(sommet):
- aucune - aucune
Effet de bord : Effet de bord :
- aucun - aucun
""" """
return sommet[2] return sommet[2]
def coincide_nom(sommet, motif): def coincide_nom(sommet, motif):
""" """
Compare le nom du sommet au motif Compare le nom du sommet au motif
@@ -169,7 +177,8 @@ def coincide_nom(sommet, motif):
- aucun - aucun
""" """
nom_sommet = nom(sommet) 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 pass

45
ensembles_dynamiques/TP/_sommets_dict.py
View File

@@ -16,6 +16,7 @@
# - altitude : INT, altitude en m # - altitude : INT, altitude en m
# - massif : STR # - massif : STR
def creer_sommet(nom, altitude, massif): def creer_sommet(nom, altitude, massif):
""" """
Construit le dico sommet. Construit le dico sommet.
@@ -31,17 +32,14 @@ def creer_sommet(nom, altitude, massif):
Pré-condition : Pré-condition :
- aucune (programmation défensive à envisager) - aucune (programmation défensive à envisager)
Effet de bord : Effet de bord :
- aucun - aucun
""" """
sommet = { sommet = {"Nom": nom, "Altitude": altitude, "Massif": massif}
"Nom": nom,
"Altitude": altitude,
"Massif": massif
}
return sommet return sommet
def altitude_en_m(altitude): def altitude_en_m(altitude):
""" """
Conversion de l'altitude en entier ("2 062 m" -> 2062) Conversion de l'altitude en entier ("2 062 m" -> 2062)
@@ -58,18 +56,19 @@ def altitude_en_m(altitude):
Effet de bord : Effet de bord :
- aucun - aucun
""" """
tmp = '' tmp = ""
for symbole in altitude: for symbole in altitude:
if not(symbole in ' m'): if not (symbole in " m"):
tmp += symbole tmp += symbole
return int(tmp) return int(tmp)
def creer_sommet_csv(ligne, massif): def creer_sommet_csv(ligne, massif):
""" """
Construit un sommet à partir d'une ligne du fichier csv. Construit un sommet à partir d'une ligne du fichier csv.
Paramètres : Paramètres :
- ligne : STR, ligne du fichier csv - ligne : STR, ligne du fichier csv
- massif : STR, basename du fichier contenant la ligne - massif : STR, basename du fichier contenant la ligne
Résultat : Résultat :
@@ -81,9 +80,10 @@ def creer_sommet_csv(ligne, massif):
Effet de bord : Effet de bord :
- aucun - aucun
""" """
nom, alt = ligne.rstrip().split(',') nom, alt = ligne.rstrip().split(",")
return creer_sommet(nom, altitude_en_m(alt), massif) return creer_sommet(nom, altitude_en_m(alt), massif)
def afficher(sommet): def afficher(sommet):
""" """
Affichage formatté du sommet. Affichage formatté du sommet.
@@ -101,7 +101,9 @@ def afficher(sommet):
- Affichage sur la sortie standard - 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): def nom(sommet):
@@ -118,9 +120,11 @@ def nom(sommet):
- aucune - aucune
Effet de bord : Effet de bord :
- aucun - aucun
""" """
return sommet["Nom"] return sommet["Nom"]
def altitude(sommet): def altitude(sommet):
""" """
Consulte l'altitude d'un sommet Consulte l'altitude d'un sommet
@@ -135,9 +139,11 @@ def altitude(sommet):
- aucune - aucune
Effet de bord : Effet de bord :
- aucun - aucun
""" """
return sommet['Altitude'] return sommet["Altitude"]
def massif(sommet): def massif(sommet):
""" """
Consulte le massif d'un sommet Consulte le massif d'un sommet
@@ -152,9 +158,11 @@ def massif(sommet):
- aucune - aucune
Effet de bord : Effet de bord :
- aucun - aucun
""" """
return sommet["Massif"] return sommet["Massif"]
def coincide_nom(sommet, motif): def coincide_nom(sommet, motif):
""" """
Compare le nom du sommet au motif Compare le nom du sommet au motif
@@ -174,7 +182,8 @@ def coincide_nom(sommet, motif):
""" """
nom_sommet = nom(sommet) 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 pass

23
ensembles_dynamiques/TP/main.py
View File

@@ -16,17 +16,18 @@ import _sommets as som
# Le module _collection définit nos ENSEMBLES # Le module _collection définit nos ENSEMBLES
# Le module _sommets définit nos SOMMETS # 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. Lecture du fichier csv contenant les caractéristiques des sommets.
Paramètres : Paramètres :
- fichier : STR, le nom complet du fichier csv à parcourir - fichier : STR, le nom complet du fichier csv à parcourir
Résultat : Résultat :
- resultat : ENSEMBLE, la collection des sommets - resultat : ENSEMBLE, la collection des sommets
Pré-conditions : Pré-conditions :
- aucune - aucune
Effets de bord : Effets de bord :
@@ -41,27 +42,29 @@ def file_2_set(fichier='./data/Chartreuse.csv'):
ligne = src.readline() ligne = src.readline()
return resultat return resultat
def rechercher(ensemble, motif): 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é. correspond à un motif donné.
Paramètres : Paramètres :
- ensemble : ENSEMBLE, la collection des somets - ensemble : ENSEMBLE, la collection des somets
- motif : STR, la chaîne de caractères à identifier - motif : STR, la chaîne de caractères à identifier
Résultat : Résultat :
- ENSEMBLE, la sous-collection des sommets satisfaisant au critère - ENSEMBLE, la sous-collection des sommets satisfaisant au critère
Pré-condition : Pré-condition :
- aucune - aucune
Effet de bord : Effet de bord :
- aucun - aucun
""" """
return col.rechercher(ensemble, motif, som.coincide_nom) return col.rechercher(ensemble, motif, som.coincide_nom)
if __name__ == '__main__': if __name__ == "__main__":
col.lister(col.supprimer_critere(file_2_set(), 'Grand', som.coincide_nom), \ col.lister(
som.afficher) col.supprimer_critere(file_2_set(), "Grand", som.coincide_nom), som.afficher
)

13
fibonacci/code1.py
View File

@@ -1,13 +1,18 @@
import numpy as np import numpy as np
def fibobo(n): def fibobo(n):
if n<= 1: if n <= 1:
return n return n
return fibobo(n-1) + fibobo(n-2) return fibobo(n - 1) + fibobo(n - 2)
print(fibobo(30)) print(fibobo(30))
def fibibi(n): def fibibi(n):
fibi = np.array([[1,1],[1,0]]) fibi = np.array([[1, 1], [1, 0]])
return np.linalg.matrix_power(fibi,n)[0][-1] return np.linalg.matrix_power(fibi, n)[0][-1]
print(fibibi(100)) print(fibibi(100))

15
fibonacci/complex.py
View File

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

19
file/old/LSC.py
View File

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

5
file/old/file.py
View File

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

1
file/old/file_LSC.py
View File

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

46
fonctions_tri/partitionement.py
View File

@@ -1,6 +1,7 @@
from typing import Any from typing import Any
def partitionement(liste: list[Any],debut,fin):
def partitionement(liste: list[Any], debut, fin):
pivot = liste[debut] pivot = liste[debut]
gauche = debut + 1 gauche = debut + 1
droite = fin - 1 droite = fin - 1
@@ -12,49 +13,16 @@ def partitionement(liste: list[Any],debut,fin):
droite -= 1 droite -= 1
if gauche < droite: if gauche < droite:
exchange(liste,gauche,droite) exchange(liste, gauche, droite)
gauche += 1 gauche += 1
droite -= 1 droite -= 1
exchange(liste,droite,debut) exchange(liste, droite, debut)
return droite return droite
def exchange(liste, indx_g, indx_d): def exchange(liste, indx_g, indx_d):
liste[indx_g],liste[indx_d] = liste[indx_d], liste[indx_g] 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))
l = [12, 4, 0, 44, 27]
print(partitionement(l, 0, len(l) - 1))

25
graphes/DS_possible/main.py
View File

@@ -1,27 +1,26 @@
graphe = { graphe = {
"node1": ["node2","node4"], "node1": ["node2", "node4"],
"node2": ["node2","node3","node6"], "node2": ["node2", "node3", "node6"],
"node3": ["node5"], "node3": ["node5"],
"node5": ["node5","node6"], "node5": ["node5", "node6"],
"node4": ["node1","node5"], "node4": ["node1", "node5"],
"node6": [] "node6": [],
} }
print(graphe["node1"]) print(graphe["node1"])
def bfs(graphe, start_node): def bfs(graphe, start_node):
queue = [start_node] queue = [start_node]
visited = set() visited = set()
while queue: while queue:
node = queue.pop(0) node = queue.pop(0)
if node not in visited: if node not in visited:
print(node) print(node)
visited.add(node) visited.add(node)
for neighbor in graphe[node]: for neighbor in graphe[node]:
if neighbor not in visited: if neighbor not in visited:
queue.append(neighbor) queue.append(neighbor)
bfs(graphe, "node1")
bfs(graphe,"node1")

30
graphes/homework_wednesday.py
View File

@@ -2,29 +2,31 @@
import heapq import heapq
def dijkstra(graph, source): def dijkstra(graph, source):
distances = {node: float('inf') for node in graph} distances = {node: float("inf") for node in graph}
distances[source] = 0 distances[source] = 0
previous = {node: None for node in graph} previous = {node: None for node in graph}
queue = [(0, source)] queue = [(0, source)]
while queue: while queue:
current_distance, current_node = heapq.heappop(queue) current_distance, current_node = heapq.heappop(queue)
if current_distance > distances[current_node]: if current_distance > distances[current_node]:
continue continue
for neighbor, weight in graph[current_node]: for neighbor, weight in graph[current_node]:
distance = current_distance + weight distance = current_distance + weight
if distance < distances[neighbor]: if distance < distances[neighbor]:
distances[neighbor] = distance distances[neighbor] = distance
previous[neighbor] = current_node previous[neighbor] = current_node
heapq.heappush(queue, (distance, neighbor)) heapq.heappush(queue, (distance, neighbor))
return distances, previous return distances, previous
def reconstruct_path(previous, start, end): def reconstruct_path(previous, start, end):
path = [] path = []
node = end node = end
@@ -34,22 +36,22 @@ def reconstruct_path(previous, start, end):
path.reverse() path.reverse()
return path return path
if __name__ == '__main__':
if __name__ == "__main__":
graph = { graph = {
"R1": [("R2", 1)], "R1": [("R2", 1)],
"R2": [("R3", 1), ("R5", 10)], "R2": [("R3", 1), ("R5", 10)],
"R3": [("R4", 1), ("R5", 1)], "R3": [("R4", 1), ("R5", 1)],
"R5": [("R4", 10)], "R5": [("R4", 10)],
"R4": [] "R4": [],
} }
source = "R1" source = "R1"
destination = "R4" destination = "R4"
distances, previous = dijkstra(graph, source) distances, previous = dijkstra(graph, source)
print("Shortest distances from", source, ":", distances) print("Shortest distances from", source, ":", distances)
path = reconstruct_path(previous, source, destination) path = reconstruct_path(previous, source, destination)
print("Shortest path from", source, "to", destination, ":", path) print("Shortest path from", source, "to", destination, ":", path)

554
graphes/leaudibidon/Water_jug.py
View File

@@ -2,345 +2,367 @@
# -*- Coding: utf-8 -*- # -*- Coding: utf-8 -*-
class Graphe_Oriente(object): class Graphe_Oriente(object):
""" """
Classe des Graphes Orientés (GO). Classe des Graphes Orientés (GO).
Les graphes sont représentés par Les graphes sont représentés par
- une liste de sommets - une liste de sommets
- leur liste d'adjacence - leur liste d'adjacence
Attributs (publics) Attributs (publics)
- sommets : liste des sommets - sommets : liste des sommets
- voisins : dictionnaire des listes d'adjacence - voisins : dictionnaire des listes d'adjacence
Méthodes (publiques) Méthodes (publiques)
- ajoute_sommet : ajout d'un sommet - ajoute_sommet : ajout d'un sommet
- ajoute_arcs : ajout d'un arc - ajoute_arcs : ajout d'un arc
""" """
def __init__(self): def __init__(self):
self.sommets = list() self.sommets = list()
self.voisins = dict() self.voisins = dict()
return None return None
def ajoute_sommet(self, s): def ajoute_sommet(self, s):
""" """
Ajoute le sommet s à l'instance de GO. 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.sommets.append(s)
self.voisins[s] = list() self.voisins[s] = list()
return None return None
def ajoute_arc(self, origine, extremite): def ajoute_arc(self, origine, extremite):
""" """
Ajoute l'arc origine -> extremite à l'instance de GO. Ajoute l'arc origine -> extremite à l'instance de GO.
:param self Graphe_Oriente: instance à laquelle ajouter un arc :param self Graphe_Oriente: instance à laquelle ajouter un arc
:param origine data: un sommet de l'instance, origine de l'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 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 :pré-condition: les sommets doivent exister
""" """
assert origine in self.sommets, "{} inconnu".format(origine) assert origine in self.sommets, "{} inconnu".format(origine)
assert extremite in self.sommets, "{} inconnu".format(extremite) assert extremite in self.sommets, "{} inconnu".format(extremite)
self.voisins[origine].append(extremite) self.voisins[origine].append(extremite)
return None return None
def construire_chemins(graphe, depart): 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 graphe GO: graphe à parcourir
:param depart data: sommet de départ dans le graphe :param depart data: sommet de départ dans le graphe
:return resultat dict: dictionnaire :return resultat dict: dictionnaire
- clef : sommet atteint - clef : sommet atteint
- valeur : tuple (longueur itinéraire, sommet prédécesseur) - valeur : tuple (longueur itinéraire, sommet prédécesseur)
:effet de bord: Aucun :effet de bord: Aucun
>>> graphe = Graphe_Oriente() >>> graphe = Graphe_Oriente()
>>> graphe.ajoute_sommet('A') >>> graphe.ajoute_sommet('A')
>>> graphe.ajoute_sommet('B') >>> graphe.ajoute_sommet('B')
>>> graphe.ajoute_sommet('C') >>> graphe.ajoute_sommet('C')
>>> graphe.ajoute_arc('A', 'B') >>> graphe.ajoute_arc('A', 'B')
>>> graphe.ajoute_arc('B', 'C') >>> graphe.ajoute_arc('B', 'C')
>>> construire_chemins(graphe, 'A') >>> construire_chemins(graphe, 'A')
{'A': (0, None), 'B': (1, 'A'), 'C': (2, 'B')} {'A': (0, None), 'B': (1, 'A'), 'C': (2, 'B')}
""" """
resultat = dict() resultat = dict()
file = [depart] # initialise une file (sous forme de liste ici) file = [depart] # initialise une file (sous forme de liste ici)
resultat[depart] = (0, None) # None car le depart n'a aucun predesseceur resultat[depart] = (0, None) # None car le depart n'a aucun predesseceur
while len(file) > 0: while len(file) > 0:
sommet = file.pop(0) # retire le premier element de la file -> FIFO sommet = file.pop(0) # retire le premier element de la file -> FIFO
for voisin in graphe.voisins[sommet]: # Parcours tous les voisins du sommet for voisin in graphe.voisins[sommet]: # Parcours tous les voisins du sommet
if voisin not in resultat: # Verifie que cette partie de l arbre (ou du graphe) n a pas deja ete explorer if (
distance = resultat[sommet][0] + 1 # Definie distance -> Distance du dernier sommet + 1 voisin not in resultat
resultat[voisin] = (distance, sommet) # Insere le nouveau sommet dans le dictionnaire ): # Verifie que cette partie de l arbre (ou du graphe) n a pas deja ete explorer
file.append(voisin) # Permet la reiteration de la boucle a partir de se sommet distance = (
resultat[sommet][0] + 1
) # Definie distance -> Distance du dernier sommet + 1
resultat[voisin] = (
distance,
sommet,
) # Insere le nouveau sommet dans le dictionnaire
file.append(
voisin
) # Permet la reiteration de la boucle a partir de se sommet
return resultat return resultat
def reconstruire_chemin_vers(dico_chemins, *arrivee): def reconstruire_chemin_vers(dico_chemins, *arrivee):
""" """
Remonte tout l'itinéraire depuis un sommet fixé Remonte tout l'itinéraire depuis un sommet fixé
vers un ou des sommets du graphe vers un ou des sommets du graphe
:param dico_chemins dict: table des longueurs/prédécessurs :param dico_chemins dict: table des longueurs/prédécessurs
:param *arrivee: nombre quelconque de sommet à atteindre :param *arrivee: nombre quelconque de sommet à atteindre
(si vide, on considère tous les sommets) (si vide, on considère tous les sommets)
:return resultat list: liste des chemins ie des listes de sommets traversés :return resultat list: liste des chemins ie des listes de sommets traversés
>>> dico_chemins = {'A': (0, None), 'B': (1, 'A'), 'C': (2, 'B')} >>> dico_chemins = {'A': (0, None), 'B': (1, 'A'), 'C': (2, 'B')}
>>> reconstruire_chemin_vers(dico_chemins, 'C') >>> reconstruire_chemin_vers(dico_chemins, 'C')
[['A', 'B', 'C']] [['A', 'B', 'C']]
""" """
chemins = list() chemins = list()
cibles = arrivee # Creer une liste avec les sommets a remonter cibles = arrivee # Creer une liste avec les sommets a remonter
if len(cibles) == 0: if len(cibles) == 0:
return list(dico_chemins.keys()) # si la liste est vide, on renvoie les chemins (sans leurs attributs) return list(
for sommet in cibles: dico_chemins.keys()
sous_chemin = [] ) # si la liste est vide, on renvoie les chemins (sans leurs attributs)
current = sommet for sommet in cibles:
while current is not None: sous_chemin = []
sous_chemin.insert(0, current) # on insere le sommet au début de la liste (permet de maintenir l ordre) current = sommet
current = dico_chemins[current][1] # on change current avec le sommet predesseceur pour que la boucle continue while current is not None:
chemins.append(sous_chemin) sous_chemin.insert(
return chemins 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): 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 :param chemin list: liste des sommets constituant le chemin
:return string: chemin mis en forme pour affichage :return string: chemin mis en forme pour affichage
""" """
long = len(chemin) - 1 long = len(chemin) - 1
return "{} etapes :\n".format(long) + "\n\t-> ".join( return "{} etapes :\n".format(long) + "\n\t-> ".join(
[str(sommet) for sommet in chemin] [str(sommet) for sommet in chemin]
) )
# DEFINITION DES OPERATIONS DE TRANSITION # DEFINITION DES OPERATIONS DE TRANSITION
def vider(numero, etat): def vider(numero, etat):
""" """
Vide un bidon Vide un bidon
:param numero INT: index du bidon :param numero INT: index du bidon
:param etat tuple: etat des bidons avant l'opération :param etat tuple: etat des bidons avant l'opération
:return tuple: nouvel etat aprés opération :return tuple: nouvel etat aprés opération
:effet de bord: aucun :effet de bord: aucun
>>> vider(1,(3,5,2)) >>> vider(1,(3,5,2))
(3, 0, 2) (3, 0, 2)
""" """
index_b = list(etat) index_b = list(etat)
index_b[numero] = 0 index_b[numero] = 0
return tuple(index_b) return tuple(index_b)
def remplir(numero, etat, capacites): def remplir(numero, etat, capacites):
""" """
Remplit un bidon Remplit un bidon
:param numero INT: index du bidon :param numero INT: index du bidon
:param etat tuple: etat des bidons avant l'opération :param etat tuple: etat des bidons avant l'opération
:param capacites tuple: capacités des bidons :param capacites tuple: capacités des bidons
:return tuple: nouvel etat aprés opération :return tuple: nouvel etat aprés opération
:effet de bord: aucun :effet de bord: aucun
>>> remplir(1, (3, 2, 1), (5, 4, 3)) >>> remplir(1, (3, 2, 1), (5, 4, 3))
(3, 4, 1) (3, 4, 1)
""" """
cap = list(capacites) cap = list(capacites)
index_b = list(etat) index_b = list(etat)
index_b[numero] = cap[numero] index_b[numero] = cap[numero]
return tuple(index_b) return tuple(index_b)
def transvaser(source, destination, etat, capacites): 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 origine int: index du bidon source
:param destination int: index du bidon destination :param destination int: index du bidon destination
:param etas tuple: etat des bidons avant l'opération :param etas tuple: etat des bidons avant l'opération
:param capacites tuple: capacités des bidons :param capacites tuple: capacités des bidons
:return tuple: nouvel etat aprés opération :return tuple: nouvel etat aprés opération
:effet de bord: aucun :effet de bord: aucun
>>> transvaser(0, 1, (3, 2, 1), (5, 4, 3)) >>> transvaser(0, 1, (3, 2, 1), (5, 4, 3))
(1, 4, 1) (1, 4, 1)
""" """
transfer_amount = min( transfer_amount = min(
list(etat)[source], list(capacites)[destination] - list(etat)[destination] list(etat)[source], list(capacites)[destination] - list(etat)[destination]
) )
new_state = list(etat) new_state = list(etat)
new_state[source] -= transfer_amount new_state[source] -= transfer_amount
new_state[destination] += transfer_amount new_state[destination] += transfer_amount
return tuple(new_state) return tuple(new_state)
# FONCTION LIEES AU GRAPHE DU WATER_JUG # FONCTION LIEES AU GRAPHE DU WATER_JUG
# Pour construire les etats # Pour construire les etats
def produit_cartesien(*listes): 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 :param *listes: un nombre quelconque de listes de tuples
:return list: une liste des tuples concaténés :return list: une liste des tuples concaténés
Exemple Exemple
-------- --------
>>> produit_cartesien([(1,2), (3, 4)], [(5, 6), (7, 8,)]) >>> 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)] [(1, 2, 5, 6), (1, 2, 7, 8), (3, 4, 5, 6), (3, 4, 7, 8)]
""" """
if listes == None: if listes == None:
return [] return []
if len(listes) == 1: if len(listes) == 1:
return listes[0] return listes[0]
result = [] result = []
for elt in listes[0]: for elt in listes[0]:
for tuples in produit_cartesien(*listes[1:]): for tuples in produit_cartesien(*listes[1:]):
result.append(elt + tuples) result.append(elt + tuples)
return result return result
def creer_water_jug(*capacites): 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 :param *capacites: capacités des bidons disponibles
:return resultat GO: le graphe orienté du W_J :return resultat GO: le graphe orienté du W_J
:pre-condition: au moins 2 bidons :pre-condition: au moins 2 bidons
:effet de bord: Aucun :effet de bord: Aucun
""" """
nb_bidons = len(capacites) nb_bidons = len(capacites)
assert nb_bidons >= 2, "Pas assez de bidons" assert nb_bidons >= 2, "Pas assez de bidons"
resultat = Graphe_Oriente() resultat = Graphe_Oriente()
# CREATION DES SOMMETS # CREATION DES SOMMETS
etats_marginaux = [ etats_marginaux = [
[(contenu,) for contenu in range(1 + capacite)] for capacite in capacites [(contenu,) for contenu in range(1 + capacite)] for capacite in capacites
] ]
etats_systeme = produit_cartesien(*etats_marginaux) etats_systeme = produit_cartesien(*etats_marginaux)
for etat in etats_systeme: for etat in etats_systeme:
resultat.ajoute_sommet(etat) resultat.ajoute_sommet(etat)
# CREATION DES TRANSITIONS # CREATION DES TRANSITIONS
for sommet in resultat.sommets: for sommet in resultat.sommets:
voisins = list() voisins = list()
# VIDER # VIDER
for bidon in range(nb_bidons): for bidon in range(nb_bidons):
voisin = vider(bidon, sommet) voisin = vider(bidon, sommet)
if voisin != sommet and not (voisin in voisins): if voisin != sommet and not (voisin in voisins):
voisins.append(voisin) voisins.append(voisin)
# REMPLIR # REMPLIR
for bidon in range(nb_bidons): for bidon in range(nb_bidons):
voisin = remplir(bidon, sommet, capacites) voisin = remplir(bidon, sommet, capacites)
if voisin != sommet and not (voisin in voisins): if voisin != sommet and not (voisin in voisins):
voisins.append(voisin) voisins.append(voisin)
# TRANSVASER # TRANSVASER
for origine in range(nb_bidons): for origine in range(nb_bidons):
for destination in range(nb_bidons): for destination in range(nb_bidons):
if origine != destination: if origine != destination:
voisin = transvaser(origine, destination, sommet, capacites) voisin = transvaser(origine, destination, sommet, capacites)
if voisin != sommet and not (voisin in voisins): if voisin != sommet and not (voisin in voisins):
voisins.append(voisin) voisins.append(voisin)
# CREATION LISTES ADJACENCE # CREATION LISTES ADJACENCE
for voisin in voisins: for voisin in voisins:
resultat.ajoute_arc(sommet, voisin) resultat.ajoute_arc(sommet, voisin)
return resultat return resultat
def atteindre(quantite, graphe_water_jug, depart=None, plus_court=False): 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 quantite int: la quantité à mesurer
:param graphe_water_jug GO: le graphe de la situation :param graphe_water_jug GO: le graphe de la situation
:param depart tuple: etat initial, sommet d'origine dans le graphe :param depart tuple: etat initial, sommet d'origine dans le graphe
(bidons tous vides si depart est None, ie non fourni) (bidons tous vides si depart est None, ie non fourni)
:param plus_court bool: si vrai, seul le(s) plus court(s) chemin(s) :param plus_court bool: si vrai, seul le(s) plus court(s) chemin(s)
est (sont) retenu(s) est (sont) retenu(s)
:return list: la liste des tuples (sommet arrivee, nb d'etapes, ititneraire) ok :return list: la liste des tuples (sommet arrivee, nb d'etapes, ititneraire) ok
""" """
if depart is None: if depart is None:
nb_bidons = len(graphe_water_jug.sommets[0]) nb_bidons = len(graphe_water_jug.sommets[0])
depart = tuple([0 for _ in range(nb_bidons)]) depart = tuple([0 for _ in range(nb_bidons)])
chemins = construire_chemins(graphe_water_jug, depart) chemins = construire_chemins(graphe_water_jug, depart)
resultat = list() resultat = list()
for sommet in chemins: for sommet in chemins:
if quantite in sommet: if quantite in sommet:
longueur, _ = chemins[sommet] longueur, _ = chemins[sommet]
chemin = reconstruire_chemin_vers(chemins, sommet).pop() chemin = reconstruire_chemin_vers(chemins, sommet).pop()
index = len(resultat) index = len(resultat)
resultat.append((sommet, longueur, chemin)) resultat.append((sommet, longueur, chemin))
while index > 0: while index > 0:
if resultat[index - 1][1] < longueur: if resultat[index - 1][1] < longueur:
break break
else: else:
resultat[index], resultat[index - 1] = ( resultat[index], resultat[index - 1] = (
resultat[index - 1], resultat[index - 1],
resultat[index], resultat[index],
) )
index -= 1 index -= 1
if len(resultat) < 2 or not (plus_court): if len(resultat) < 2 or not (plus_court):
return resultat return resultat
mini = resultat[0][1] mini = resultat[0][1]
return [element for element in resultat if element[1] == mini] return [element for element in resultat if element[1] == mini]
def main(): def main():
solutions = atteindre(4, creer_water_jug(3,5)) solutions = atteindre(4, creer_water_jug(3, 5))
for (sommet_final, nb_etapes, chemin) in solutions: for sommet_final, nb_etapes, chemin in solutions:
print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes") print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes")
print(affichage_chemin(chemin)) print(affichage_chemin(chemin))
print("--------------------------------------") print("--------------------------------------")
def question1(): 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(): def question2():
for i in range(10): for i in range(10):
resolutions = atteindre(i,creer_water_jug(3,5),None, True) resolutions = atteindre(i, creer_water_jug(3, 5), None, True)
for (sommet_final, nb_etapes, chemin) in resolutions: for sommet_final, nb_etapes, chemin in resolutions:
print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes") print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes")
print(affichage_chemin(chemin)) print(affichage_chemin(chemin))
print("--------------------------------------") print("--------------------------------------")
def question3(): def question3():
solution = atteindre(4,creer_water_jug(3,5),None,True) solution = atteindre(4, creer_water_jug(3, 5), None, True)
for (sommet_final, nb_etapes, chemin) in solution: for sommet_final, nb_etapes, chemin in solution:
print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes") print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes")
print(affichage_chemin(chemin)) print(affichage_chemin(chemin))
print("--------------------------------------") print("--------------------------------------")
def question4(): def question4():
solution = atteindre(1,creer_water_jug(3,5,9),None,True) solution = atteindre(1, creer_water_jug(3, 5, 9), None, True)
for (sommet_final, nb_etapes, chemin) in solution: for sommet_final, nb_etapes, chemin in solution:
print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes") print(f"sommet atteint: {sommet_final}, en {nb_etapes} etapes")
print(affichage_chemin(chemin)) print(affichage_chemin(chemin))
print("--------------------------------------") print("--------------------------------------")
if __name__ == "__main__": if __name__ == "__main__":
import doctest import doctest
doctest.testmod(verbose=True)
main() doctest.testmod(verbose=True)
question1() main()
question2() question1()
question3() question2()
question4() question3()
question4()

32
graphes/leaudibidon/correction.py
View File

@@ -1,22 +1,20 @@
def produit_cartesien(*listes): def produit_cartesien(*listes):
if not listes: if not listes:
return [] return []
if len(listes) == 1: if len(listes) == 1:
return listes[0] return listes[0]
if len(listes) == 2: if len(listes) == 2:
liste1, liste2 = listes liste1, liste2 = listes
resultat = list() resultat = list()
for tuple_1 in liste1: for tuple_1 in liste1:
for tuple_2 in liste2: for tuple_2 in liste2:
resultat.append(tuple_1 + tuple_2) resultat.append(tuple_1 + tuple_2)
return resultat return resultat
liste1, *reste = listes liste1, *reste = listes
return produit_cartesien(liste1, produit_cartesien(*reste)) return produit_cartesien(liste1, produit_cartesien(*reste))
liste1 = [(_,) for _ in range(3)] liste1 = [(_,) for _ in range(3)]
liste2 = [(_,) for _ in range(5)] liste2 = [(_,) for _ in range(5)]
liste3 = [(_,)for _ in range(8)] liste3 = [(_,) for _ in range(8)]
print(produit_cartesien(liste1,liste2)) print(produit_cartesien(liste1, liste2))

28
graphes/leaudibidon/main.py
View File

@@ -1,31 +1,35 @@
class leaudibidon(object): class leaudibidon(object):
def __init__(self,capacity): def __init__(self, capacity):
self.capacity = capacity self.capacity = capacity
self.quantity = 0 self.quantity = 0
def fullfill_b5(b5,b3): def fullfill_b5(b5, b3):
b5.quantity = b5.capacity b5.quantity = b5.capacity
print("Fullfill b5") print("Fullfill b5")
def fullfill_b3(b5,b3): def fullfill_b3(b5, b3):
b3.quantity = b3.capacity b3.quantity = b3.capacity
print("Fullfill b3") print("Fullfill b3")
def void_b5(b5,b3): def void_b5(b5, b3):
b5.quantity = 0 b5.quantity = 0
print("void b5") print("void b5")
def void_b3(b5, b3):
def void_b3(b5,b3):
b3.quantity = 0 b3.quantity = 0
print("void b3") print("void b3")
def transfer_b5_b3(b5,b3): def transfer_b5_b3(b5, b3):
transfer_amount = min(b5.quantity, b3.capacity - b3.quantity) transfer_amount = min(b5.quantity, b3.capacity - b3.quantity)
b5.quantity, b3.quantity = b5.quantity - transfer_amount, b3.quantity + transfer_amount b5.quantity, b3.quantity = (
b5.quantity - transfer_amount,
b3.quantity + transfer_amount,
def transfer_b3_b5(b5,b3): )
def transfer_b3_b5(b5, b3):
transfer_amount = min(b3.quantity, b5.capacity - b5.quantity) 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,
)

6
graphes/maze/fifo.py
View File

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

4
graphes/maze/lifo.py
View File

@@ -2,7 +2,7 @@ class Queue:
def __init__(self) -> None: def __init__(self) -> None:
self.element = [] self.element = []
def enfiler(self,element): def enfiler(self, element):
self.element.append(element) self.element.append(element)
def est_vide(self): def est_vide(self):
@@ -16,5 +16,5 @@ class Queue:
return len(self.element) return len(self.element)
def index(self, k): def index(self, k):
assert self.est_vide() , "La file est vide" assert self.est_vide(), "La file est vide"
return self.element[k] return self.element[k]

4
graphes/maze/main.py
View File

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

14
graphes/maze/maze_creator.py
View File

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

9
graphes/maze/test.py
View File

@@ -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 # Initialisation
pile = Pile() 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" assert not pile.est_vide(), "Erreur : La pile ne devrait pas être vide"
pile.defiler() pile.defiler()
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 # Test de defiler
pile.empiler(7) pile.empiler(7)
@@ -48,4 +52,3 @@ except AssertionError as e:
pass # Test réussi pass # Test réussi
print("Tous les tests sont passés avec succès !") print("Tous les tests sont passés avec succès !")

5
graphes/monday_homework.py
View File

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

7
magic_square/TDliste2liste/exercice1.py
View File

@@ -1,4 +1,4 @@
def appartient(elt,tableau): def appartient(elt, tableau):
for i in tableau: for i in tableau:
if i == elt: if i == elt:
return True return True
@@ -6,6 +6,7 @@ def appartient(elt,tableau):
continue continue
return False return False
if __name__ == "__main__": if __name__ == "__main__":
print(appartient(5,[1,2,3,4,5,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])) print(appartient(5, [1, 2, 3, 4, 6, 7, 8, 9, 10]))

4
magic_square/TDliste2liste/exercice2.py
View File

@@ -7,6 +7,7 @@ def max_local(tableau):
continue continue
return maximum return maximum
def indice_max(tableau): def indice_max(tableau):
maximum = max_local(tableau) maximum = max_local(tableau)
for i in range(len(tableau)): for i in range(len(tableau)):
@@ -15,7 +16,8 @@ def indice_max(tableau):
else: else:
continue continue
if __name__ == "__main__": 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(max_local(l1))
print(indice_max(l1)) print(indice_max(l1))

7
magic_square/TDliste2liste/exercice3.py
View File

@@ -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)] return [[0 for _ in range(m)] for _ in range(n)]
def cree_tableau_carre_n(n): def cree_tableau_carre_n(n):
return [[0 for _ in range(n)] for _ in range(n)] return [[0 for _ in range(n)] for _ in range(n)]
if __name__ == "__main__": if __name__ == "__main__":
print(cree_tableau_n_m(3,5)) print(cree_tableau_n_m(3, 5))
print(cree_tableau_carre_n(5)) print(cree_tableau_carre_n(5))

3
magic_square/TDliste2liste/exercice4.py
View File

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

5
magic_square/TDliste2liste/exercice5.py
View File

@@ -2,8 +2,11 @@ def transpose(carre):
n = len(carre) # Nombre de lignes (ou colonnes, car c'est une matrice carrée) 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)] return [[carre[j][i] for j in range(n)] for i in range(n)]
def transpose_en_place(carre): def transpose_en_place(carre):
n = len(carre) # Nombre de lignes (ou colonnes) n = len(carre) # Nombre de lignes (ou colonnes)
for i in range(n): 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 carre[i][j], carre[j][i] = carre[j][i], carre[i][j] # Échange des éléments

2
magic_square/TDliste2liste/exercice6.py
View File

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

30
magic_square/magic_square.py
View File

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

29
magic_square/td_carre_magique.py
View File

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

8
partition_fusion/code.py
View File

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

27
partition_fusion/code2.py
View File

@@ -1,28 +1,31 @@
from random import shuffle from random import shuffle
i = 0 i = 0
def fusion(liste_1,liste_2):
def fusion(liste_1, liste_2):
global i global i
if len(liste_1) == 0: if len(liste_1) == 0:
return liste_2 return liste_2
if len(liste_2) == 0: if len(liste_2) == 0:
return liste_1 return liste_1
if liste_1[0] <= liste_2[0]: if liste_1[0] <= liste_2[0]:
i+=1 i += 1
return [liste_1[0]] + fusion(liste_1[1:],liste_2) return [liste_1[0]] + fusion(liste_1[1:], liste_2)
i+=1 i += 1
return [liste_2[0]] + fusion(liste_1,liste_2[1:]) return [liste_2[0]] + fusion(liste_1, liste_2[1:])
def tri_pf(liste): def tri_pf(liste):
global i global i
if len(liste)<=1: if len(liste) <= 1:
return liste return liste
i+=1 i += 1
millieu = len(liste)//2 millieu = len(liste) // 2
return fusion(tri_pf(liste[:millieu]), tri_pf(liste[millieu:])) return fusion(tri_pf(liste[:millieu]), tri_pf(liste[millieu:]))
test = [23, 8, 20, 10, 13, 1]
test = [23,8,20,10,13,1] print(test, i)
print(test,i)
test = tri_pf(test) test = tri_pf(test)
print(test, i ) print(test, i)

16
partition_fusion/liste.py
View File

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

33
partition_fusion/partition_fusion.py
View File

@@ -12,16 +12,16 @@ import liste as fifo
def taille(liste): def taille(liste):
a = 0 a = 0
while not(fifo.est_vide(liste)): while not (fifo.est_vide(liste)):
liste = fifo.queue(liste) liste = fifo.queue(liste)
a+=1 a += 1
return a return a
def divise2(liste): def divise2(liste):
n = taille(liste) n = taille(liste)
droite, gauche = partition(liste,0,n//2) droite, gauche = partition(liste, 0, n // 2)
return droite,gauche return droite, gauche
def renverser(liste): def renverser(liste):
@@ -41,30 +41,29 @@ def partition(liste, debut, fin):
if fifo.est_vide(current): if fifo.est_vide(current):
break break
current = fifo.queue(current) current = fifo.queue(current)
segment_inversé = fifo.creer_liste() segment_inversé = fifo.creer_liste()
for _ in range(fin - debut): for _ in range(fin - debut):
if fifo.est_vide(current): if fifo.est_vide(current):
break break
segment_inversé = fifo.ajouter(segment_inversé, fifo.tete(current)) segment_inversé = fifo.ajouter(segment_inversé, fifo.tete(current))
current = fifo.queue(current) current = fifo.queue(current)
segment = renverser(segment_inversé) segment = renverser(segment_inversé)
return current, segment return current, segment
def fusion(gauche,droite): def fusion(gauche, droite):
if fifo.est_vide(gauche): if fifo.est_vide(gauche):
return droite return droite
if fifo.est_vide(droite): if fifo.est_vide(droite):
return gauche return gauche
if fifo.tete(gauche)<=fifo.tete(droite): if fifo.tete(gauche) <= fifo.tete(droite):
return fifo.ajouter(fusion(fifo.queue(gauche),droite),fifo.tete(gauche)) return fifo.ajouter(fusion(fifo.queue(gauche), droite), fifo.tete(gauche))
else: 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): def merge_sort(liste):
@@ -72,19 +71,19 @@ def merge_sort(liste):
if fifo.est_vide(liste): if fifo.est_vide(liste):
return liste return liste
elif fifo.est_vide(fifo.queue(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) gauche, droite = divise2(liste)
tri1 = merge_sort(gauche) # recursif
tri2 = merge_sort(droite) # recursif
tri1 = merge_sort(gauche) # recursif return fusion(tri1, tri2)
tri2 = merge_sort(droite) # recursif
return fusion(tri1,tri2)
if __name__ == "__main__": if __name__ == "__main__":
liste = fifo.creer_liste() liste = fifo.creer_liste()
for i in reversed(range(100)): for i in reversed(range(100)):
liste = fifo.ajouter(liste,i) liste = fifo.ajouter(liste, i)
print(liste) print(liste)
print("Après avoir trié la liste:") print("Après avoir trié la liste:")

9
perfect_number/main.py
View File

@@ -1,11 +1,14 @@
import math import math
def find_diviseur(number): def find_diviseur(number):
diviseurs = [] diviseurs = []
limit = int(number/2) limit = int(number / 2)
for i in range(1,limit): for i in range(1, limit):
if number %i == 0: if number % i == 0:
diviseurs.append(i) diviseurs.append(i)
return diviseurs return diviseurs
if __name__ == "__main__": if __name__ == "__main__":
print(find_diviseur(15)) print(find_diviseur(15))

50
pygame/V2/balle/balle.py
View File

@@ -3,39 +3,43 @@ from constantes import *
import raquette import raquette
from math import * from math import *
class Balle(object): class Balle(object):
def __init__(self): def __init__(self):
self.rayon = 10 self.rayon = 10
self.xpos = LARGEUR_ECRAN/2 self.xpos = LARGEUR_ECRAN / 2
self.ypos = HAUTEUR_ECRAN/2 self.ypos = HAUTEUR_ECRAN / 2
self.xvit =4.5 self.xvit = 4.5
self.yvit = 3.0 self.yvit = 3.0
def deplace(self, raquette):
def deplace(self,raquette):
self.xpos += self.xvit self.xpos += self.xvit
self.ypos += self.yvit self.ypos += self.yvit
self.rebonds(raquette) self.rebonds(raquette)
def affiche(self, ecran): 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): def rebonds(self, raquette):
if self.xpos + self.rayon > LARGEUR_ECRAN or self.xpos - self.rayon < 0: 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: if self.ypos + self.rayon > HAUTEUR_ECRAN or self.ypos - self.rayon < 0:
self.yvit = - self.yvit self.yvit = -self.yvit
if self.ypos >= HAUTEUR_ECRAN-20: if self.ypos >= HAUTEUR_ECRAN - 20:
if self.xpos >= raquette.xpos: if self.xpos >= raquette.xpos:
if self.xpos <= raquette.xpos + raquette.largeur : if self.xpos <= raquette.xpos + raquette.largeur:
self.yvit = - self.yvit self.yvit = -self.yvit
if self.xpos >= raquette.xpos + raquette.largeur - raquette.largeur/10: if (
self.xpos
>= raquette.xpos + raquette.largeur - raquette.largeur / 10
):
self.xvit = 4.0 self.xvit = 4.0
self.yvit = 6.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.xvit = -4.0
self.yvit = 6.0 self.yvit = 6.0

53
pygame/V2/balle/balle_rebondissante.py
View File

@@ -2,13 +2,13 @@ import sys, pygame
import balle import balle
from constantes import * from constantes import *
pygame.init() #initialisation des modules de pygame pygame.init() # initialisation des modules de pygame
# Creation de la fenetre # Creation de la fenetre
ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN)) 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() clock = pygame.time.Clock()
@@ -16,28 +16,27 @@ b1 = balle.Balle()
bouge = False bouge = False
while True: #Demarrage de la boucle infinie while True: # Demarrage de la boucle infinie
for event in pygame.event.get(): for event in pygame.event.get():
if event.type == pygame.QUIT: #Evt de sortie de boucle if event.type == pygame.QUIT: # Evt de sortie de boucle
sys.exit() sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1: elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
bouge = not bouge bouge = not bouge
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 bouge = not bouge
ecran.fill(BLANC) ecran.fill(BLANC)
b1.deplace() b1.deplace()
b1.affiche(ecran) b1.affiche(ecran)
pygame.display.update() pygame.display.update()
ecran.fill(BLANC)
ecran.fill(BLANC) if bouge:
if bouge: b1.deplace()
b1.deplace() b1.affiche(ecran)
b1.affiche(ecran)
pygame.display.update() # rafraichissement
pygame.display.update() #rafraichissement clock.tick(60)
clock.tick(60)
if __name__ == "__main__":
if __name__ == '__main__':
b1 = balle.Balle() b1 = balle.Balle()

24
pygame/V2/balle/casse_brique.py
View File

@@ -1,4 +1,4 @@
import sys, pygame import sys, pygame
import balle import balle
import raquette import raquette
from constantes import * from constantes import *
@@ -6,10 +6,10 @@ from constantes import *
pygame.init() pygame.init()
# Creation de la fenetre # 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 # Titre de la fenetre
pygame.display.set_caption('Casse_Brique') pygame.display.set_caption("Casse_Brique")
clock = pygame.time.Clock() clock = pygame.time.Clock()
@@ -19,25 +19,23 @@ bouge = False
bouge_gauche_raquette = False bouge_gauche_raquette = False
bouge_droite_raquette = False bouge_droite_raquette = False
while True : while True:
for event in pygame.event.get() : for event in pygame.event.get():
if event.type == pygame.QUIT : if event.type == pygame.QUIT:
sys.exit() 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 bouge = not bouge
if pygame.key.get_pressed()[pygame.K_q]: if pygame.key.get_pressed()[pygame.K_q]:
r1.deplaceGauche() r1.deplaceGauche()
if pygame.key.get_pressed()[pygame.K_d]: if pygame.key.get_pressed()[pygame.K_d]:
r1.deplaceDroite() r1.deplaceDroite()
ecran.fill(BLANC) ecran.fill(BLANC)
if bouge : if bouge:
b1.deplace(r1) b1.deplace(r1)
b1.deplace(r1) b1.deplace(r1)
b1.affiche(ecran) b1.affiche(ecran)
r1.affiche(ecran) r1.affiche(ecran)

2
pygame/V2/balle/constantes.py
View File

@@ -1,6 +1,6 @@
##########Definitions des constantes ##########Definitions des constantes
# Taille de la fenetre # Taille de la fenetre
LARGEUR_ECRAN = 600 LARGEUR_ECRAN = 600
HAUTEUR_ECRAN = 800 HAUTEUR_ECRAN = 800
# Couleur # Couleur
BLANC = (255, 255, 255) BLANC = (255, 255, 255)

67
pygame/V2/balle/raquette.py
View File

@@ -1,56 +1,59 @@
import pygame import pygame
from constantes import * from constantes import *
class Raquette: class Raquette:
""" """
Definie une raquette qui se deplace horizontalement Definie une raquette qui se deplace horizontalement
dans le bas de la fenetre ecran dans le bas de la fenetre ecran
Attributs : largeur (int defaut 100), Attributs : largeur (int defaut 100),
xpos (int defaut LARGEUR_ECRAN//2 - self.largeur//2), xpos (int defaut LARGEUR_ECRAN//2 - self.largeur//2),
vit (int defaut 6) vit (int defaut 6)
L'épaisseur de la raquette est de 10 L'épaisseur de la raquette est de 10
Methodes : deplaceGauche, deplaceDroite, affiche Methodes : deplaceGauche, deplaceDroite, affiche
""" """
def __init__(self): def __init__(self):
self.largeur = 100 self.largeur = 100
self.xpos = LARGEUR_ECRAN//2 - self.largeur//2 self.xpos = LARGEUR_ECRAN // 2 - self.largeur // 2
self.vit = 6 self.vit = 6
def deplaceGauche(self): def deplaceGauche(self):
""" """
Deplace la raquette de vit vers la gauche Deplace la raquette de vit vers la gauche
Parametres : Parametres :
self : Raquette self : Raquette
Return : Return :
None None
Effet de bord : Effet de bord :
Modifie l'attribut xpos en lui enlevant, Modifie l'attribut xpos en lui enlevant,
si c'est possible la valeur de vit (et met xpos à 0 sinon) si c'est possible la valeur de vit (et met xpos à 0 sinon)
""" """
self.xpos -= self.vit self.xpos -= self.vit
if self.xpos < 0: if self.xpos < 0:
self.xpos = 0 self.xpos = 0
def deplaceDroite(self): def deplaceDroite(self):
""" """
Deplace la raquette de vit vers la droite Deplace la raquette de vit vers la droite
Parametres : Parametres :
self : Raquette self : Raquette
Return : Return :
None None
Effet de bord : Effet de bord :
Modifie l'attribut xpos en lui ajoutant, Modifie l'attribut xpos en lui ajoutant,
si c'est possible la valeur de vit (et met xpos à si c'est possible la valeur de vit (et met xpos à
600-self.largeur sinon sinon) 600-self.largeur sinon sinon)
""" """
self.xpos += self.vit self.xpos += self.vit
if self.xpos > LARGEUR_ECRAN - self.largeur: if self.xpos > LARGEUR_ECRAN - self.largeur:
self.xpos = LARGEUR_ECRAN - self.largeur self.xpos = LARGEUR_ECRAN - self.largeur
def affiche(self, ecran): 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

41
pygame/bouncing_ball/ball.py
View File

@@ -1,20 +1,21 @@
import sys, pygame import sys, pygame
import balle import balle
##########Definitions des constantes ##########Definitions des constantes
# Taille de la fenetre # Taille de la fenetre
LARGEUR_ECRAN = 600 LARGEUR_ECRAN = 600
HAUTEUR_ECRAN = 800 HAUTEUR_ECRAN = 800
# Couleur # Couleur
BLANC = (255, 255, 255) BLANC = (255, 255, 255)
NOIR = (0, 0, 0) NOIR = (0, 0, 0)
pygame.init() #initialisation des modules de pygame pygame.init() # initialisation des modules de pygame
# Creation de la fenetre # Creation de la fenetre
ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN)) 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() clock = pygame.time.Clock()
@@ -22,21 +23,19 @@ b1 = balle.Balle()
bouge = False bouge = False
while True: #Demarrage de la boucle infinie while True: # Demarrage de la boucle infinie
for event in pygame.event.get(): for event in pygame.event.get():
if event.type == pygame.QUIT: #Evt de sortie de boucle if event.type == pygame.QUIT: # Evt de sortie de boucle
sys.exit() sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN: elif event.type == pygame.MOUSEBUTTONDOWN:
bouge = not bouge bouge = not bouge
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 bouge = not bouge
ecran.fill(BLANC)
if bouge:
b1.deplace()
b1.affiche(ecran)
pygame.display.update() #rafraichissement
clock.tick(60)
ecran.fill(BLANC)
if bouge:
b1.deplace()
b1.affiche(ecran)
pygame.display.update() # rafraichissement
clock.tick(60)

39
pygame/bouncing_ball/balle.py
View File

@@ -1,23 +1,24 @@
import pygame 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 ) : class Balle:
self.rayon = 10 """
self.xpos = 300.0 Definie une balle qui se deplace dans la fenetre ecran
self.ypos = 400.0 Attributs : rayon , xpos , ypos , xvit , yvit
self.xvit = 4.5 Methodes : deplace , affiche
self.yvit = 3.0 """
def deplace ( self ) : def __init__(self):
self.xpos += self.xvit self.rayon = 10
self.ypos += self.yvit self.xpos = 300.0
if self.xpos + self.rayon > 600 or self.xpos - self.rayon < 0: self.ypos = 400.0
self.xvit = - self.xvit self.xvit = 4.5
elif self.ypos + self.rayon > 800 or self.ypos - self.rayon < 0: self.yvit = 3.0
self.yvit = - self.yvit
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

3
pygame/bouncing_ball/constantes.py
View File

@@ -1,5 +1,4 @@
LARGEUR_ECRAN = 600 LARGEUR_ECRAN = 600
HAUTEUR_ECRAN = 800 HAUTEUR_ECRAN = 800
BLANC = (255,255,255) BLANC = (255, 255, 255)

9
pygame/bouncing_ball/raquette.py
View File

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

41
pygame/bouncing_ball_project/ball.py
View File

@@ -1,20 +1,21 @@
import sys, pygame import sys, pygame
import balle import balle
##########Definitions des constantes ##########Definitions des constantes
# Taille de la fenetre # Taille de la fenetre
LARGEUR_ECRAN = 600 LARGEUR_ECRAN = 600
HAUTEUR_ECRAN = 800 HAUTEUR_ECRAN = 800
# Couleur # Couleur
BLANC = (255, 255, 255) BLANC = (255, 255, 255)
NOIR = (0, 0, 0) NOIR = (0, 0, 0)
pygame.init() #initialisation des modules de pygame pygame.init() # initialisation des modules de pygame
# Creation de la fenetre # Creation de la fenetre
ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN)) 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() clock = pygame.time.Clock()
@@ -22,21 +23,19 @@ b1 = balle.Balle()
bouge = False bouge = False
while True: #Demarrage de la boucle infinie while True: # Demarrage de la boucle infinie
for event in pygame.event.get(): for event in pygame.event.get():
if event.type == pygame.QUIT: #Evt de sortie de boucle if event.type == pygame.QUIT: # Evt de sortie de boucle
sys.exit() sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN: elif event.type == pygame.MOUSEBUTTONDOWN:
bouge = not bouge bouge = not bouge
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 bouge = not bouge
ecran.fill(BLANC)
if bouge:
b1.deplace()
b1.affiche(ecran)
pygame.display.update() #rafraichissement
clock.tick(60)
ecran.fill(BLANC)
if bouge:
b1.deplace()
b1.affiche(ecran)
pygame.display.update() # rafraichissement
clock.tick(60)

5
pygame/bouncing_ball_project/balle.py
View File

@@ -1,6 +1,7 @@
import pygame import pygame
import pygame import pygame
class Balle: class Balle:
""" """
Definie une balle qui se deplace dans la fenetre ecran Definie une balle qui se deplace dans la fenetre ecran
@@ -29,4 +30,6 @@ class Balle:
Paramètres : Paramètres :
ecran : pygame.Surface - L'écran où dessiner la balle 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
)

8
pygame/bouncing_ball_project/bouncing_ball_game.py
View File

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

3
pygame/bouncing_ball_project/constantes.py
View File

@@ -1,5 +1,4 @@
LARGEUR_ECRAN = 600 LARGEUR_ECRAN = 600
HAUTEUR_ECRAN = 800 HAUTEUR_ECRAN = 800
BLANC = (255,255,255) BLANC = (255, 255, 255)

14
pygame/bouncing_ball_project/raquette.py
View File

@@ -1,12 +1,13 @@
import pygame import pygame
from constantes import * from constantes import *
class Raquette: class Raquette:
""" """
Définit une raquette qui se déplace horizontalement Définit une raquette qui se déplace horizontalement
dans le bas de la fenêtre écran. dans le bas de la fenêtre écran.
Attributs : largeur (int, par défaut 100), Attributs : largeur (int, par défaut 100),
xpos (int, par défaut LARGEUR_ECRAN//2 - largeur//2), xpos (int, par défaut LARGEUR_ECRAN//2 - largeur//2),
vit (int, par défaut 6) vit (int, par défaut 6)
L'épaisseur de la raquette est de 10. L'épaisseur de la raquette est de 10.
Méthodes : deplaceGauche, deplaceDroite, affiche Méthodes : deplaceGauche, deplaceDroite, affiche
@@ -33,7 +34,10 @@ class Raquette:
""" """
Dessine la raquette sur l'écran. 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

57
pygame/lab_py/main.py
View File

@@ -3,9 +3,9 @@ import random
import sys import sys
# Paramètres de la grille # Paramètres de la grille
CELL_SIZE = 20 # Taille d'une cellule en pixels CELL_SIZE = 20 # Taille d'une cellule en pixels
COLS = 30 # Nombre de colonnes COLS = 30 # Nombre de colonnes
ROWS = 30 # Nombre de lignes ROWS = 30 # Nombre de lignes
WIDTH = COLS * CELL_SIZE WIDTH = COLS * CELL_SIZE
HEIGHT = ROWS * CELL_SIZE HEIGHT = ROWS * CELL_SIZE
@@ -15,12 +15,13 @@ WHITE = (255, 255, 255)
GRAY = (100, 100, 100) GRAY = (100, 100, 100)
GREEN = (0, 255, 0) GREEN = (0, 255, 0)
class Cell: class Cell:
def __init__(self, i, j): def __init__(self, i, j):
self.i = i # Numéro de la colonne self.i = i # Numéro de la colonne
self.j = j # Numéro de la ligne self.j = j # Numéro de la ligne
# Chaque cellule possède 4 murs, tous présents initialement # 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 self.visited = False
def draw(self, surface): def draw(self, surface):
@@ -31,23 +32,29 @@ class Cell:
# Remplir la cellule (si visitée) AVANT de dessiner les murs # Remplir la cellule (si visitée) AVANT de dessiner les murs
if self.visited: if self.visited:
pygame.draw.rect(surface, GRAY, (x, y, CELL_SIZE, CELL_SIZE)) pygame.draw.rect(surface, GRAY, (x, y, CELL_SIZE, CELL_SIZE))
# Dessiner les murs par-dessus la couleur de fond # 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)) pygame.draw.line(surface, WHITE, (x, y), (x + CELL_SIZE, y))
if self.walls['right']: if self.walls["right"]:
pygame.draw.line(surface, WHITE, (x + CELL_SIZE, y), (x + CELL_SIZE, y + CELL_SIZE)) pygame.draw.line(
if self.walls['bottom']: surface, WHITE, (x + CELL_SIZE, y), (x + CELL_SIZE, y + CELL_SIZE)
pygame.draw.line(surface, WHITE, (x + CELL_SIZE, y + CELL_SIZE), (x, y + CELL_SIZE)) )
if self.walls['left']: if self.walls["bottom"]:
pygame.draw.line(
surface, WHITE, (x + CELL_SIZE, y + CELL_SIZE), (x, y + CELL_SIZE)
)
if self.walls["left"]:
pygame.draw.line(surface, WHITE, (x, y + CELL_SIZE), (x, y)) pygame.draw.line(surface, WHITE, (x, y + CELL_SIZE), (x, y))
def get_cell(i, j): def get_cell(i, j):
"""Retourne la cellule aux coordonnées (i, j) si elle existe.""" """Retourne la cellule aux coordonnées (i, j) si elle existe."""
if 0 <= i < COLS and 0 <= j < ROWS: if 0 <= i < COLS and 0 <= j < ROWS:
return grid[i][j] return grid[i][j]
return None return None
def get_unvisited_neighbors(cell): def get_unvisited_neighbors(cell):
"""Retourne la liste des voisins non visités de la cellule donnée.""" """Retourne la liste des voisins non visités de la cellule donnée."""
neighbors = [] neighbors = []
@@ -68,9 +75,10 @@ def get_unvisited_neighbors(cell):
left = get_cell(i - 1, j) left = get_cell(i - 1, j)
if left and not left.visited: if left and not left.visited:
neighbors.append(left) neighbors.append(left)
return neighbors return neighbors
def remove_walls(current, next_cell): def remove_walls(current, next_cell):
""" """
Enlève les murs entre la cellule courante et le voisin sélectionné. 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 dx = next_cell.i - current.i
dy = next_cell.j - current.j dy = next_cell.j - current.j
if dx == 1: # Voisin à droite if dx == 1: # Voisin à droite
current.walls['right'] = False current.walls["right"] = False
next_cell.walls['left'] = False next_cell.walls["left"] = False
elif dx == -1: # Voisin à gauche elif dx == -1: # Voisin à gauche
current.walls['left'] = False current.walls["left"] = False
next_cell.walls['right'] = False next_cell.walls["right"] = False
elif dy == 1: # Voisin en bas elif dy == 1: # Voisin en bas
current.walls['bottom'] = False current.walls["bottom"] = False
next_cell.walls['top'] = False next_cell.walls["top"] = False
elif dy == -1: # Voisin en haut elif dy == -1: # Voisin en haut
current.walls['top'] = False current.walls["top"] = False
next_cell.walls['bottom'] = False next_cell.walls["bottom"] = False
def main(): def main():
global grid global grid
@@ -99,7 +108,7 @@ def main():
# Création de la grille : une matrice de cellules # Création de la grille : une matrice de cellules
grid = [[Cell(i, j) for j in range(ROWS)] for i in range(COLS)] grid = [[Cell(i, j) for j in range(ROWS)] for i in range(COLS)]
# Initialisation de l'algorithme DFS # Initialisation de l'algorithme DFS
current = grid[0][0] # Départ en haut à gauche current = grid[0][0] # Départ en haut à gauche
current.visited = True current.visited = True
@@ -143,12 +152,12 @@ def main():
x = current.i * CELL_SIZE x = current.i * CELL_SIZE
y = current.j * CELL_SIZE y = current.j * CELL_SIZE
pygame.draw.rect(screen, GREEN, (x, y, CELL_SIZE, CELL_SIZE)) pygame.draw.rect(screen, GREEN, (x, y, CELL_SIZE, CELL_SIZE))
pygame.display.flip() pygame.display.flip()
pygame.quit() pygame.quit()
sys.exit() sys.exit()
if __name__ == '__main__':
main()
if __name__ == "__main__":
main()

28
recursivite/TD1.py
View File

@@ -2,27 +2,35 @@ def factorielle(number: int):
if number == 0: if number == 0:
return 1 return 1
else: else:
return number * factorielle(number-1) return number * factorielle(number - 1)
def modulo(a, b): def modulo(a, b):
if b-a < 0: if b - a < 0:
return b return b
elif b == 0: elif b == 0:
return b return b
else: else:
return modulo(a,b-a) return modulo(a, b - a)
def somme(n): def somme(n):
if n == 0: if n == 0:
return n return n
else: else:
return(n+somme(n-1)) return n + somme(n - 1)
def init_quotient(a,b):
def init_quotient(a, b):
i = 0 i = 0
return (quotient(a,b,i)) return quotient(a, b, i)
def quotient(a,b,i):
if b == 0 or b-a < 0:
def quotient(a, b, i):
if b == 0 or b - a < 0:
return i return i
else: 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))

13
recursivite/exercice_MJoannic/dichotomie/iteratif/main.py
View File

@@ -1,6 +1,7 @@
from sort_list import sort_list 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 """This function return return True if element is in liste False else
Args: Args:
@@ -12,18 +13,20 @@ def dichotomie(liste: list, element: any,bypass_sorting = False)->bool:
""" """
if liste == []: if liste == []:
return False 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: if bypass_sorting == False:
liste = sort_list(liste) 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 end = N
while (find != True) and (start <= end): while (find != True) and (start <= end):
middle = (start + end)//2 middle = (start + end) // 2
if liste[middle] == element: if liste[middle] == element:
find = True find = True
elif element > liste[middle]: elif element > liste[middle]:
start = middle+1 start = middle + 1
else: else:
end = middle - 1 end = middle - 1
return find return find

72
recursivite/exercice_MJoannic/dichotomie/iteratif/tester.py
View File

@@ -1,56 +1,84 @@
from main import dichotomie from main import dichotomie
def tester(): 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] liste2 = liste1[:-1]
liste3 = [7,4,1,8,5,2,9,6,3,0] liste3 = [7, 4, 1, 8, 5, 2, 9, 6, 3, 0]
liste3_2 = [7,7,7,7,7,7,7,8] liste3_2 = [7, 7, 7, 7, 7, 7, 7, 8]
liste4 = [] liste4 = []
liste5 = [1] liste5 = [1]
liste6 = [1.0,2.0,3.1,4.2,8.6,8.3] liste6 = [1.0, 2.0, 3.1, 4.2, 8.6, 8.3]
liste7 = [-1,-2,-2,-3,-4] 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(
liste9 = [i for i in range(1,100000)] "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, 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 # Tests pour liste2
assert dichotomie(liste2, 9) == True, "Test échoué : 9 devrait être dans 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 # Tests pour liste3
assert dichotomie(liste3, 8) == True, "Test échoué : 8 devrait être dans 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 # Tests pour liste3_2
assert dichotomie(liste3_2, 7) == True, "Test échoué : 7 devrait être dans 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 # Tests pour liste4
assert dichotomie(liste4, 1) == False, "Test échoué : Liste vide, 1 ne devrait pas être dans liste4" assert (
assert dichotomie(liste4, 0) == False, "Test échoué : Liste vide, 0 ne devrait pas être dans liste4" dichotomie(liste4, 1) == False
), "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
assert (
dichotomie(liste4, 0) == False
), "Test échoué : Liste vide, 0 ne devrait pas être dans liste4"
# Tests pour liste5 # Tests pour liste5
assert dichotomie(liste5, 1) == True, "Test échoué : 1 devrait être dans 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 # Tests pour liste6
assert dichotomie(liste6, 3.1) == True, "Test échoué : 3.1 devrait être dans 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 # Tests pour liste7
assert dichotomie(liste7, -3) == True, "Test échoué : -3 devrait être dans 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 # Tests pour liste8
assert dichotomie(liste8, "L") == True, "Test échoué : 'L' devrait être dans 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 # Tests pour liste9
assert dichotomie(liste9, 99999, True) == True, "Test échoué : 99999 devrait être dans liste9" # bypass = True because sorting_list is very slow assert (
assert dichotomie(liste9, 0,True) == False, "Test échoué : 5 ne devrait pas être dans liste9"# bypass = True because sorting_list is very slow dichotomie(liste9, 99999, True) == True
), "Test échoué : 99999 devrait être dans liste9" # bypass = True because sorting_list is very slow
assert (
dichotomie(liste9, 0, True) == False
), "Test échoué : 5 ne devrait pas être dans liste9" # bypass = True because sorting_list is very slow
print("Tous les tests ont réussi !") print("Tous les tests ont réussi !")
if __name__ == '__main__': if __name__ == "__main__":
tester() tester()

23
recursivite/exercice_MJoannic/dichotomie/recursif/correction/V1.py
View File

@@ -1,28 +1,31 @@
from typing import Any from typing import Any
def est_triee(liste: list)->bool: def est_triee(liste: list) -> bool:
if len(liste) <= 1: if len(liste) <= 1:
return True return True
index = 0 index = 0
while (index < len(liste) - 1) and (liste[index]<=liste[index + 1]): while (index < len(liste) - 1) and (liste[index] <= liste[index + 1]):
index+=1 index += 1
return index>= len(liste) - 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" assert est_triee(liste), "Pas de recherche sur une liste non triee"
def aux(liste, element): def aux(liste, element):
if len(liste) == 0: if len(liste) == 0:
return True return True
else: else:
pivot = liste[len(liste)//2] pivot = liste[len(liste) // 2]
if pivot == element: if pivot == element:
return True return True
if element < pivot: if element < pivot:
return aux(liste[len(liste)//2], element) return aux(liste[len(liste) // 2], element)
return aux(liste[len(liste)//3 + 1:], element) return aux(liste[len(liste) // 3 + 1 :], element)
return aux(liste,element)
return aux(liste, element)
print(search([1,2,3],2)) print(search([1, 2, 3], 2))

17
recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/main.py
View File

@@ -1,7 +1,14 @@
from sort_list import sort_list from sort_list import sort_list
from typing import Any 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. """Performs a dichotomy search to determine if an element exists in a list or not.
Args: Args:
@@ -32,6 +39,10 @@ def dichotomie(liste: list[Any], element: Any, start: int = 0, end: int = None,
if liste[middle] == element: if liste[middle] == element:
return middle return middle
elif element < liste[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: 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

85
recursivite/exercice_MJoannic/dichotomie/recursif/myself/idx/tester.py
View File

@@ -1,5 +1,6 @@
from main import dichotomie from main import dichotomie
def tester(): 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] liste2 = liste1[:-1]
@@ -9,72 +10,108 @@ def tester():
liste5 = [1] liste5 = [1]
liste6 = [1.0, 2.0, 3.1, 4.2, 8.6, 8.3] liste6 = [1.0, 2.0, 3.1, 4.2, 8.6, 8.3]
liste7 = [-1, -2, -2, -3, -4] 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)] liste9 = [i for i in range(1, 100000)]
# Tests pour liste1 # 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") 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") print("Test n°2 réussi")
# Tests pour liste2 # 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") 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") print("Test n°4 réussi")
''' """
# Tests pour liste3 (tri nécessaire) # Tests pour liste3 (tri nécessaire)
assert dichotomie(liste3, 8) == 7, "Test échoué : 8 devrait être à l'index 7 après tri dans liste3" assert dichotomie(liste3, 8) == 7, "Test échoué : 8 devrait être à l'index 7 après tri dans liste3"
print("Test n°5 réussi") print("Test n°5 réussi")
assert dichotomie(liste3, 11) == -1, "Test échoué : 11 ne devrait pas être dans liste3" assert dichotomie(liste3, 11) == -1, "Test échoué : 11 ne devrait pas être dans liste3"
print("Test n°6 réussi") print("Test n°6 réussi")
''' """
# Tests pour liste3_2 # Tests pour liste3_2
assert dichotomie(liste3_2, 7) == 3, "Test échoué : 7 devrait être dans liste3_2" assert dichotomie(liste3_2, 7) == 3, "Test échoué : 7 devrait être dans liste3_2"
print("Test n°7 réussi") 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") print("Test n°8 réussi")
# Tests pour liste4 # Tests pour liste4
print(dichotomie(liste4,1)) print(dichotomie(liste4, 1))
assert dichotomie(liste4, 1) == -1, "Test échoué : Liste vide, 1 ne devrait pas être dans liste4" assert (
dichotomie(liste4, 1) == -1
), "Test échoué : Liste vide, 1 ne devrait pas être dans liste4"
print("Test n°9 réussi") 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") print("Test n°10 réussi")
# Tests pour liste5 # 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") 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") print("Test n°12 réussi")
# Tests pour liste6 # 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") 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") print("Test n°14 réussi")
# Tests pour liste7 (tri nécessaire) # 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") 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") print("Test n°16 réussi")
# Tests pour liste8 # 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") 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") print("Test n°18 réussi")
# Tests pour liste9 (tri déjà fait) # 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") 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("Test n°20 réussi")
print("Tous les tests ont réussi !") print("Tous les tests ont réussi !")
if __name__ == '__main__': if __name__ == "__main__":
tester() tester()

17
recursivite/exercice_MJoannic/dichotomie/recursif/myself/main.py
View File

@@ -1,7 +1,14 @@
from sort_list import sort_list from sort_list import sort_list
from typing import Any 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. """Performs a dichotomy search to determine if an element exists in a list or not.
Args: Args:
@@ -33,6 +40,10 @@ def dichotomie(liste: list[Any], element: Any, start: int = 0, end: int = None,
if liste[middle] == element: if liste[middle] == element:
return True return True
elif element < liste[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: 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

72
recursivite/exercice_MJoannic/dichotomie/recursif/myself/tester.py
View File

@@ -1,78 +1,106 @@
from main import dichotomie from main import dichotomie
def tester(): 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] liste2 = liste1[:-1]
liste3 = [7,4,1,8,5,2,9,6,3,0] liste3 = [7, 4, 1, 8, 5, 2, 9, 6, 3, 0]
liste3_2 = [7,7,7,7,7,7,7,8] liste3_2 = [7, 7, 7, 7, 7, 7, 7, 8]
liste4 = [] liste4 = []
liste5 = [1] liste5 = [1]
liste6 = [1.0,2.0,3.1,4.2,8.6,8.3] liste6 = [1.0, 2.0, 3.1, 4.2, 8.6, 8.3]
liste7 = [-1,-2,-2,-3,-4] 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(
liste9 = [i for i in range(1,100000)] "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 # Tests pour liste1
assert dichotomie(liste1, 5) == True, "Test échoué : 5 devrait être dans liste1" assert dichotomie(liste1, 5) == True, "Test échoué : 5 devrait être dans liste1"
print("Test n°1 done") 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") print("Test n°2 done")
# Tests pour liste2 # Tests pour liste2
assert dichotomie(liste2, 9) == True, "Test échoué : 9 devrait être dans liste2" assert dichotomie(liste2, 9) == True, "Test échoué : 9 devrait être dans liste2"
print("Test n°3 done") 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") print("Test n°4 done")
# Tests pour liste3 # Tests pour liste3
assert dichotomie(liste3, 8) == True, "Test échoué : 8 devrait être dans liste3" assert dichotomie(liste3, 8) == True, "Test échoué : 8 devrait être dans liste3"
print("Test n°5 done") 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") print("Test n°6 done")
# Tests pour liste3_2 # Tests pour liste3_2
assert dichotomie(liste3_2, 7) == True, "Test échoué : 7 devrait être dans liste3_2" assert dichotomie(liste3_2, 7) == True, "Test échoué : 7 devrait être dans liste3_2"
print("Test n°7 done") 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") print("Test n°8 done")
# Tests pour liste4 # 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") 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") print("Test n°10 done")
# Tests pour liste5 # Tests pour liste5
assert dichotomie(liste5, 1) == True, "Test échoué : 1 devrait être dans liste5" assert dichotomie(liste5, 1) == True, "Test échoué : 1 devrait être dans liste5"
print("Test n°11 done") 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") print("Test n°12 done")
# Tests pour liste6 # Tests pour liste6
assert dichotomie(liste6, 3.1) == True, "Test échoué : 3.1 devrait être dans liste6" assert dichotomie(liste6, 3.1) == True, "Test échoué : 3.1 devrait être dans liste6"
print("Test n°13 done") 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") print("Test n°14 done")
# Tests pour liste7 # Tests pour liste7
assert dichotomie(liste7, -3) == True, "Test échoué : -3 devrait être dans liste7" assert dichotomie(liste7, -3) == True, "Test échoué : -3 devrait être dans liste7"
print("Test n°15 done") 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") print("Test n°16 done")
# Tests pour liste8 # Tests pour liste8
assert dichotomie(liste8, "L") == True, "Test échoué : 'L' devrait être dans liste8" assert dichotomie(liste8, "L") == True, "Test échoué : 'L' devrait être dans liste8"
print("Test n°17 done") 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") print("Test n°18 done")
# Tests pour liste9 # 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") 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("Test n°20 done")
print("Tous les tests ont reussi !") print("Tous les tests ont reussi !")
if __name__ == '__main__': if __name__ == "__main__":
tester() tester()

5
recursivite/exercice_MJoannic/palindrom.py
View File

@@ -1,4 +1,4 @@
def is_palindrom(word)->bool: def is_palindrom(word) -> bool:
word = list(word) word = list(word)
if len(word) < 2: if len(word) < 2:
return True return True
@@ -9,4 +9,5 @@ def is_palindrom(word)->bool:
else: else:
return False return False
print(is_palindrom("do geese see god".replace(' ', '')))
print(is_palindrom("do geese see god".replace(" ", "")))

23
recursivite/exercice_MJoannic/sqrt/correction/main.py
View File

@@ -1,41 +1,40 @@
def racine(n): def racine(n):
def aux(gauche, droite): def aux(gauche, droite):
if gauche > droite: if gauche > droite:
return droite return droite
milieu = (gauche + droite) // 2 milieu = (gauche + droite) // 2
if milieu * milieu == n: if milieu * milieu == n:
return milieu return milieu
elif milieu * milieu > n: elif milieu * milieu > n:
return aux(gauche, milieu - 1) return aux(gauche, milieu - 1)
else: else:
return aux(milieu + 1, droite) return aux(milieu + 1, droite)
return aux(0, n)
return aux(0, n)
def racine_decimale(n, precision=1e-6): def racine_decimale(n, precision=1e-6):
def aux(gauche, droite): def aux(gauche, droite):
milieu = (gauche + droite) / 2 milieu = (gauche + droite) / 2
if droite - gauche < precision: if droite - gauche < precision:
return milieu return milieu
if milieu * milieu == n: if milieu * milieu == n:
return milieu return milieu
elif milieu * milieu < n: elif milieu * milieu < n:
return aux(milieu, droite) return aux(milieu, droite)
else: else:
return aux(gauche, milieu) return aux(gauche, milieu)
partie_entiere = racine(n) partie_entiere = racine(n)
return aux(partie_entiere, partie_entiere + 1) return aux(partie_entiere, partie_entiere + 1)

21
recursivite/exercice_MJoannic/sqrt/main.py
View File

@@ -2,9 +2,9 @@
def racine_raphson(number: float, precision: float) -> float: def racine_raphson(number: float, precision: float) -> float:
assert number > 0, "La racine du nombre n'est pas réelle." assert number > 0, "La racine du nombre n'est pas réelle."
y = (number / 3)+ 1 y = (number / 3) + 1
diff = precision + 1 diff = precision + 1
while diff > precision: while diff > precision:
y_next = (y + number / y) / 2.0 y_next = (y + number / y) / 2.0
diff = abs(y_next - y) diff = abs(y_next - y)
@@ -12,11 +12,18 @@ def racine_raphson(number: float, precision: float) -> float:
return y return y
if __name__ == "__main__": 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. """Recherche la partie entière de la racine carrée d'un nombre en utilisant une recherche dichotomique.
Args: Args:
@@ -45,6 +52,7 @@ def dichotomie(liste: list[any], element: any, start: int = 0, end: int = None,
else: else:
return dichotomie(liste, element, start, middle - 1, bypass_sorting=True) return dichotomie(liste, element, start, middle - 1, bypass_sorting=True)
def racine_dich(number: int) -> int: def racine_dich(number: int) -> int:
""" """
Calcul de la partie entière de la racine carrée d'un nombre entier. 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) return dichotomie(liste, number)
if __name__ == "__main__": if __name__ == "__main__":
print(racine_dich(36)) # Retourne 6 print(racine_dich(36)) # Retourne 6
print(racine_dich(20)) # Retourne 4 print(racine_dich(20)) # Retourne 4
print(racine_dich(0)) # Retourne 0 print(racine_dich(0)) # Retourne 0
print(racine_dich(1)) # Retourne 1 print(racine_dich(1)) # Retourne 1

8
trees/genealogie/genealogie.py
View File

@@ -119,12 +119,14 @@ class Arbre(object):
return resultat return resultat
return Arbre() return Arbre()
def ajouter(self,elt): def ajouter(self, elt):
if self.est_vide(): if self.est_vide():
return Arbre(racine=elt) return Arbre(racine=elt)
else: else:
return Arbre(elt,self) return Arbre(elt, self)
def enlever(self,elt):
def enlever(self, elt):
pass pass
def display(self): def display(self):
pass pass

8
trees/qdj.py
View File

@@ -4,10 +4,10 @@ def calcul_taille(arbre, sommet):
while reste: while reste:
if arbre[sommet].voisin_gauche(): if arbre[sommet].voisin_gauche():
sommet = arbre[sommet].voisin_gauche() sommet = arbre[sommet].voisin_gauche()
i+=1 i += 1
elif arbre[sommet].voisin_droite(): elif arbre[sommet].voisin_droite():
sommet = arbre[sommet].voisin_droite() sommet = arbre[sommet].voisin_droite()
i+=1 i += 1
return i return i
@@ -15,11 +15,11 @@ def correction(arbre):
if arbre.est_vide(): if arbre.est_vide():
return 0 return 0
else: else:
return 1+correction(arbre.gauche()) + correction(arbre.droite()) return 1 + correction(arbre.gauche()) + correction(arbre.droite())
def hauteur(arbre): def hauteur(arbre):
if arbre.est_vide(): if arbre.est_vide():
return -1 return -1
else: else:
return max([arbre.droite(),arbre.gauche()]) return max([arbre.droite(), arbre.gauche()])

0
python/bitab.py → turing/bitab.py
View File

32
turing/machine.py
View File

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

2
turing/mc.py
View File

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