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

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

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

7
TDliste2liste/exercice1.py
View File

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

4
TDliste2liste/exercice2.py
View File

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

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

3
TDliste2liste/exercice4.py
View File

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

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)
return [[carre[j][i] for j in range(n)] for i in range(n)]
def transpose_en_place(carre):
n = len(carre) # Nombre de lignes (ou colonnes)
for i in range(n):
for j in range(i + 1, n): # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés
for j in range(
i + 1, n
): # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés
carre[i][j], carre[j][i] = carre[j][i], carre[i][j] # Échange des éléments

2
TDliste2liste/exercice6.py
View File

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

115
casse-brique/main.py
View File

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

4
cesar/chiffrement.py
View File

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

14
crypto/algo.py
View File

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

13
ensembles_dynamiques/TP/_collection.py
View File

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

14
ensembles_dynamiques/TP/_collection_list.py
View File

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

21
ensembles_dynamiques/TP/_sommets.py
View File

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

33
ensembles_dynamiques/TP/_sommets_dict.py
View File

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

11
ensembles_dynamiques/TP/main.py
View File

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

13
fibonacci/code1.py
View File

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

15
fibonacci/complex.py
View File

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

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

5
file/old/file.py
View File

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

1
file/old/file_LSC.py
View File

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

46
fonctions_tri/partitionement.py
View File

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

17
graphes/DS_possible/main.py
View File

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

10
graphes/homework_wednesday.py
View File

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

552
graphes/leaudibidon/Water_jug.py
View File

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

32
graphes/leaudibidon/correction.py
View File

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

26
graphes/leaudibidon/main.py
View File

@@ -1,31 +1,35 @@
class leaudibidon(object):
def __init__(self,capacity):
def __init__(self, capacity):
self.capacity = capacity
self.quantity = 0
def fullfill_b5(b5,b3):
def fullfill_b5(b5, b3):
b5.quantity = b5.capacity
print("Fullfill b5")
def fullfill_b3(b5,b3):
def fullfill_b3(b5, b3):
b3.quantity = b3.capacity
print("Fullfill b3")
def void_b5(b5,b3):
def void_b5(b5, b3):
b5.quantity = 0
print("void b5")
def void_b3(b5,b3):
def void_b3(b5, b3):
b3.quantity = 0
print("void b3")
def transfer_b5_b3(b5,b3):
def transfer_b5_b3(b5, b3):
transfer_amount = min(b5.quantity, b3.capacity - b3.quantity)
b5.quantity, b3.quantity = b5.quantity - transfer_amount, b3.quantity + transfer_amount
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)
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:
self.element = []
def empiler(self,element)->None:
def empiler(self, element) -> None:
self.element.append(element)
def est_vide(self)->bool:
def est_vide(self) -> bool:
return len(self.element) == 0
def defiler(self):
assert not self.est_vide(), "La pile est vide"
return self.element.pop()
def size(self)->int:
def size(self) -> int:
return len(self.element)
def index(self, k):

4
graphes/maze/lifo.py
View File

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

4
graphes/maze/main.py
View File

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

12
graphes/maze/maze_creator.py
View File

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

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
pile = Pile()
@@ -13,7 +15,9 @@ assert pile.element == [5, 10], "Erreur : Les éléments de la pile ne correspon
assert not pile.est_vide(), "Erreur : La pile ne devrait pas être vide"
pile.defiler()
pile.defiler()
assert pile.est_vide(), "Erreur : La pile devrait être vide après avoir défiler tous les éléments"
assert (
pile.est_vide()
), "Erreur : La pile devrait être vide après avoir défiler tous les éléments"
# Test de defiler
pile.empiler(7)
@@ -48,4 +52,3 @@ except AssertionError as e:
pass # Test réussi
print("Tous les tests sont passés avec succès !")

5
graphes/monday_homework.py
View File

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

7
magic_square/TDliste2liste/exercice1.py
View File

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

4
magic_square/TDliste2liste/exercice2.py
View File

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

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

3
magic_square/TDliste2liste/exercice4.py
View File

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

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)
return [[carre[j][i] for j in range(n)] for i in range(n)]
def transpose_en_place(carre):
n = len(carre) # Nombre de lignes (ou colonnes)
for i in range(n):
for j in range(i + 1, n): # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés
for j in range(
i + 1, n
): # Commencer à j = i + 1 pour éviter de réécrire les éléments déjà transposés
carre[i][j], carre[j][i] = carre[j][i], carre[i][j] # Échange des éléments

2
magic_square/TDliste2liste/exercice6.py
View File

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

30
magic_square/magic_square.py
View File

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

29
magic_square/td_carre_magique.py
View File

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

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

27
partition_fusion/code2.py
View File

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

16
partition_fusion/liste.py
View File

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

29
partition_fusion/partition_fusion.py
View File

@@ -12,16 +12,16 @@ import liste as fifo
def taille(liste):
a = 0
while not(fifo.est_vide(liste)):
while not (fifo.est_vide(liste)):
liste = fifo.queue(liste)
a+=1
a += 1
return a
def divise2(liste):
n = taille(liste)
droite, gauche = partition(liste,0,n//2)
return droite,gauche
droite, gauche = partition(liste, 0, n // 2)
return droite, gauche
def renverser(liste):
@@ -54,17 +54,16 @@ def partition(liste, debut, fin):
return current, segment
def fusion(gauche,droite):
def fusion(gauche, droite):
if fifo.est_vide(gauche):
return droite
if fifo.est_vide(droite):
return gauche
if fifo.tete(gauche)<=fifo.tete(droite):
return fifo.ajouter(fusion(fifo.queue(gauche),droite),fifo.tete(gauche))
if fifo.tete(gauche) <= fifo.tete(droite):
return fifo.ajouter(fusion(fifo.queue(gauche), droite), fifo.tete(gauche))
else:
return fifo.ajouter(fusion(gauche,fifo.queue(droite)),fifo.tete(droite))
return fifo.ajouter(fusion(gauche, fifo.queue(droite)), fifo.tete(droite))
def merge_sort(liste):
@@ -72,19 +71,19 @@ def merge_sort(liste):
if fifo.est_vide(liste):
return liste
elif fifo.est_vide(fifo.queue(liste)):
return liste # si elle ne contient que un elt
return liste # si elle ne contient que un elt
gauche, droite = divise2(liste)
tri1 = merge_sort(gauche) # recursif
tri2 = merge_sort(droite) # recursif
tri1 = merge_sort(gauche) # recursif
tri2 = merge_sort(droite) # recursif
return fusion(tri1, tri2)
return fusion(tri1,tri2)
if __name__ == "__main__":
liste = fifo.creer_liste()
for i in reversed(range(100)):
liste = fifo.ajouter(liste,i)
liste = fifo.ajouter(liste, i)
print(liste)
print("Après avoir trié la liste:")

9
perfect_number/main.py
View File

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

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

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

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

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

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

@@ -6,10 +6,10 @@ from constantes import *
pygame.init()
# Creation de la fenetre
ecran = pygame.display.set_mode((LARGEUR_ECRAN,HAUTEUR_ECRAN))
ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
# Titre de la fenetre
pygame.display.set_caption('Casse_Brique')
pygame.display.set_caption("Casse_Brique")
clock = pygame.time.Clock()
@@ -19,11 +19,11 @@ bouge = False
bouge_gauche_raquette = False
bouge_droite_raquette = False
while True :
for event in pygame.event.get() :
if event.type == pygame.QUIT :
while True:
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE :
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
bouge = not bouge
if pygame.key.get_pressed()[pygame.K_q]:
@@ -33,11 +33,9 @@ while True :
ecran.fill(BLANC)
if bouge :
if bouge:
b1.deplace(r1)
b1.deplace(r1)
b1.affiche(ecran)
r1.affiche(ecran)

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

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

35
pygame/bouncing_ball/ball.py
View File

@@ -1,5 +1,6 @@
import sys, pygame
import balle
##########Definitions des constantes
# Taille de la fenetre
LARGEUR_ECRAN = 600
@@ -8,13 +9,13 @@ HAUTEUR_ECRAN = 800
BLANC = (255, 255, 255)
NOIR = (0, 0, 0)
pygame.init() #initialisation des modules de pygame
pygame.init() # initialisation des modules de pygame
# Creation de la fenetre
ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
ecran.fill(BLANC)
pygame.display.set_caption('Balle rebondissante')
pygame.display.set_caption("Balle rebondissante")
clock = pygame.time.Clock()
@@ -22,21 +23,19 @@ b1 = balle.Balle()
bouge = False
while True: #Demarrage de la boucle infinie
for event in pygame.event.get():
if event.type == pygame.QUIT: #Evt de sortie de boucle
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
bouge = not bouge
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
bouge = not bouge
while True: # Demarrage de la boucle infinie
for event in pygame.event.get():
if event.type == pygame.QUIT: # Evt de sortie de boucle
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
bouge = not bouge
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
bouge = not bouge
ecran.fill(BLANC)
if bouge:
b1.deplace()
b1.affiche(ecran)
ecran.fill(BLANC)
if bouge:
b1.deplace()
b1.affiche(ecran)
pygame.display.update() #rafraichissement
clock.tick(60)
pygame.display.update() # rafraichissement
clock.tick(60)

39
pygame/bouncing_ball/balle.py
View File

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

3
pygame/bouncing_ball/constantes.py
View File

@@ -1,5 +1,4 @@
LARGEUR_ECRAN = 600
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
ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
ecran.fill(BLANC)
pygame.display.set_caption('Balle rebondissante avec raquette')
pygame.display.set_caption("Balle rebondissante avec raquette")
clock = pygame.time.Clock()
@@ -37,8 +37,10 @@ while True: # Boucle principale
balle.deplace()
# Collision balle-raquette
if (balle.ypos + balle.rayon >= HAUTEUR_ECRAN - 20 and
raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur):
if (
balle.ypos + balle.rayon >= HAUTEUR_ECRAN - 20
and raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur
):
balle.yvit = -balle.yvit
balle.affiche(ecran)
@@ -46,4 +48,3 @@ while True: # Boucle principale
pygame.display.update()
clock.tick(60)

35
pygame/bouncing_ball_project/ball.py
View File

@@ -1,5 +1,6 @@
import sys, pygame
import balle
##########Definitions des constantes
# Taille de la fenetre
LARGEUR_ECRAN = 600
@@ -8,13 +9,13 @@ HAUTEUR_ECRAN = 800
BLANC = (255, 255, 255)
NOIR = (0, 0, 0)
pygame.init() #initialisation des modules de pygame
pygame.init() # initialisation des modules de pygame
# Creation de la fenetre
ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
ecran.fill(BLANC)
pygame.display.set_caption('Balle rebondissante')
pygame.display.set_caption("Balle rebondissante")
clock = pygame.time.Clock()
@@ -22,21 +23,19 @@ b1 = balle.Balle()
bouge = False
while True: #Demarrage de la boucle infinie
for event in pygame.event.get():
if event.type == pygame.QUIT: #Evt de sortie de boucle
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
bouge = not bouge
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
bouge = not bouge
while True: # Demarrage de la boucle infinie
for event in pygame.event.get():
if event.type == pygame.QUIT: # Evt de sortie de boucle
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN:
bouge = not bouge
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
bouge = not bouge
ecran.fill(BLANC)
if bouge:
b1.deplace()
b1.affiche(ecran)
ecran.fill(BLANC)
if bouge:
b1.deplace()
b1.affiche(ecran)
pygame.display.update() #rafraichissement
clock.tick(60)
pygame.display.update() # rafraichissement
clock.tick(60)

5
pygame/bouncing_ball_project/balle.py
View File

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

8
pygame/bouncing_ball_project/bouncing_ball_game.py
View File

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

3
pygame/bouncing_ball_project/constantes.py
View File

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

10
pygame/bouncing_ball_project/raquette.py
View File

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

49
pygame/lab_py/main.py
View File

@@ -3,9 +3,9 @@ import random
import sys
# Paramètres de la grille
CELL_SIZE = 20 # Taille d'une cellule en pixels
COLS = 30 # Nombre de colonnes
ROWS = 30 # Nombre de lignes
CELL_SIZE = 20 # Taille d'une cellule en pixels
COLS = 30 # Nombre de colonnes
ROWS = 30 # Nombre de lignes
WIDTH = COLS * CELL_SIZE
HEIGHT = ROWS * CELL_SIZE
@@ -15,12 +15,13 @@ WHITE = (255, 255, 255)
GRAY = (100, 100, 100)
GREEN = (0, 255, 0)
class Cell:
def __init__(self, i, j):
self.i = i # Numéro de la colonne
self.j = j # Numéro de la ligne
# Chaque cellule possède 4 murs, tous présents initialement
self.walls = {'top': True, 'right': True, 'bottom': True, 'left': True}
self.walls = {"top": True, "right": True, "bottom": True, "left": True}
self.visited = False
def draw(self, surface):
@@ -33,21 +34,27 @@ class Cell:
pygame.draw.rect(surface, GRAY, (x, y, CELL_SIZE, CELL_SIZE))
# Dessiner les murs par-dessus la couleur de fond
if self.walls['top']:
if self.walls["top"]:
pygame.draw.line(surface, WHITE, (x, y), (x + CELL_SIZE, y))
if self.walls['right']:
pygame.draw.line(surface, WHITE, (x + CELL_SIZE, y), (x + CELL_SIZE, y + CELL_SIZE))
if self.walls['bottom']:
pygame.draw.line(surface, WHITE, (x + CELL_SIZE, y + CELL_SIZE), (x, y + CELL_SIZE))
if self.walls['left']:
if self.walls["right"]:
pygame.draw.line(
surface, WHITE, (x + CELL_SIZE, y), (x + CELL_SIZE, y + CELL_SIZE)
)
if self.walls["bottom"]:
pygame.draw.line(
surface, WHITE, (x + CELL_SIZE, y + CELL_SIZE), (x, y + CELL_SIZE)
)
if self.walls["left"]:
pygame.draw.line(surface, WHITE, (x, y + CELL_SIZE), (x, y))
def get_cell(i, j):
"""Retourne la cellule aux coordonnées (i, j) si elle existe."""
if 0 <= i < COLS and 0 <= j < ROWS:
return grid[i][j]
return None
def get_unvisited_neighbors(cell):
"""Retourne la liste des voisins non visités de la cellule donnée."""
neighbors = []
@@ -71,6 +78,7 @@ def get_unvisited_neighbors(cell):
return neighbors
def remove_walls(current, next_cell):
"""
Enlève les murs entre la cellule courante et le voisin sélectionné.
@@ -78,17 +86,18 @@ def remove_walls(current, next_cell):
dx = next_cell.i - current.i
dy = next_cell.j - current.j
if dx == 1: # Voisin à droite
current.walls['right'] = False
next_cell.walls['left'] = False
current.walls["right"] = False
next_cell.walls["left"] = False
elif dx == -1: # Voisin à gauche
current.walls['left'] = False
next_cell.walls['right'] = False
current.walls["left"] = False
next_cell.walls["right"] = False
elif dy == 1: # Voisin en bas
current.walls['bottom'] = False
next_cell.walls['top'] = False
current.walls["bottom"] = False
next_cell.walls["top"] = False
elif dy == -1: # Voisin en haut
current.walls['top'] = False
next_cell.walls['bottom'] = False
current.walls["top"] = False
next_cell.walls["bottom"] = False
def main():
global grid
@@ -149,6 +158,6 @@ def main():
pygame.quit()
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:
return 1
else:
return number * factorielle(number-1)
return number * factorielle(number - 1)
def modulo(a, b):
if b-a < 0:
if b - a < 0:
return b
elif b == 0:
return b
else:
return modulo(a,b-a)
return modulo(a, b - a)
def somme(n):
if n == 0:
return n
else:
return(n+somme(n-1))
def init_quotient(a,b):
return n + somme(n - 1)
def init_quotient(a, b):
i = 0
return (quotient(a,b,i))
def quotient(a,b,i):
if b == 0 or b-a < 0:
return quotient(a, b, i)
def quotient(a, b, i):
if b == 0 or b - a < 0:
return i
else:
return(quotient(a,b-a,i+1))
return quotient(a, b - a, i + 1)
print(init_quotient(6,18))
print(init_quotient(6, 18))

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

8
trees/genealogie/genealogie.py
View File

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

8
trees/qdj.py
View File

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

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

32
turing/machine.py
View File

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

2
turing/mc.py
View File

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