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

qdj

Browse Source
This commit is contained in:
Spectre
2025-05-07 09:50:29 +02:00
parent 63382f122a
commit f603e11fda
28 changed files with 26 additions and 1276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

263
file/old/LSC.py
View File

@@ -1,263 +0,0 @@
"""
Librairie des Listes Simplement Chaînées.
Elle met à distribution cette structure de données et son interface.
@author: L. JOANNIC
"""
# ############################################################################
class Liste_Simplement_Chainee(object):
"""
Classe des Listes Simplement Chainees.
Attributs
- _tete : None si vide, Maillon sinon.
Méthodes
- est_vide
- ajouter_en_tete
- tete
- queue
"""
def __init__(self):
"""
Construire une instance de Liste Simplement Chainee.
Returns
-------
None.
"""
self._tete = None
return None
def est_vide(self):
"""
Tester si l'instance est vide.
Returns
-------
bool
Vrai ssi la liste est vide.
"""
return self._tete is None
def ajouter_en_tete(self, element):
"""
Ajouter l'élément en tête de liste.
Parameters
----------
element : type de donnee
Donnnée à ajouter à la liste.
Returns
-------
resultat : Liste_Simplement_Chainee
La liste à abonder.
"""
resultat = Liste_Simplement_Chainee()
resultat._tete = Maillon(element, self)
return resultat
def tete(self):
"""
Renvoyer la donnée stockée en tête de liste.
Returns
-------
type de donnee quelconque
donnee en tete.
"""
assert not (self.est_vide()), "Liste Vide"
return self._tete.donnee
def queue(self):
"""
Renvoyer la sous-liste suivant le maillon de tete.
Returns
-------
Liste_Simplement_Chainee
Queue de la liste.
"""
assert not (self.est_vide()), "Liste Vide"
return self._tete.suite
# ############################################################################
def creer_liste_vide():
"""
Créer une liste simplement chainee vide.
Returns
-------
Liste_Simplement_Chainee
Liste vide.
Effets de bord
--------------
Aucun
"""
return Liste_Simplement_Chainee()
def est_vide(liste):
"""
Tester si la liste simplement chainee est vide.
Parameters
----------
liste : Liste Simplement Chainee
Liste à tester.
Returns
-------
bool
Vrai ssi la liste est vide.
Effets de bord
--------------
Aucun
"""
return liste.est_vide()
def ajouter_en_tete(liste, element):
"""
Inserer un element en tete de liste simplemeent chainee.
Parameters
----------
liste : LSC
Liste à abonder.
element : type de donnee
Donnee à aouter.
Returns
-------
LSC, copie de liste à laquelle element a été ajouté en tete.
Effets de bord
--------------
Aucun
"""
return liste.ajouter_en_tete(element)
def tete(liste):
"""
Consulter la tete de liste.
Parameters
----------
liste : LSC
Liste à consulter.
Returns
-------
type de donnée
valeur de la tete de liste.
Effets de bord
--------------
Aucun
"""
return liste.tete()
def queue(liste):
"""
Renvoyer la liste sans sa tete.
Parameters
----------
liste : LSC
Liste à étêter.
Returns
-------
LSC
Liste sans son maillon de tête.
Effets de bord
--------------
Aucun
"""
return liste.queue()
def afficher_liste(liste, taille=-1):
"""
Afficher la liste en format de présentation.
Parameters
----------
liste : LSC
Liste à énumérer.
Returns
-------
None.
Effets de bord
--------------
Affichage à l'écran.
"""
reste = liste
compteur = 0
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("+-----")
return None
# ############################################################################
class Maillon(object):
"""
Classe des Maillons d'une Liste Simplement Chainee.
Attributs
- donnee : donnee stockee dans le maillon
- suite : liste simplemement chainee suivant le maillon
"""
def __init__(self, donnee=None, suite=Liste_Simplement_Chainee()):
"""
Construire une instance de la classe des Maillons.
Parameters
----------
donnee : type de donnee, optional
Donnee initiale dans le Maillon. The default is None.
suite : LSC, optional
Sous-liste suivant le Maillon courant.
The default is Liste_Simplement_Chainee().
Returns
-------
None.
"""
self.donnee = donnee
self.suite = suite
return None
# ############################################################################

61
file/old/file.py
View File

@@ -1,61 +0,0 @@
def creer_file_vide():
"""
Crée une nouvelle file vide.
Returns:
list: Une liste vide représentant la file.
"""
return []
def est_vide(file):
"""
Vérifie si une file est vide.
Args:
file (list): La file à vérifier.
Returns:
bool: `True` si la file est vide, `False` sinon.
"""
return len(file) == 0
def enfiler(file, elt):
"""
Ajoute un élément à la fin de la file.
Args:
file (list): La file à laquelle ajouter l'élément.
elt: L'élément à ajouter.
Returns:
None
"""
return file.append(elt)
def defiler(file: list):
"""
Retire et renvoie le premier élément de la file.
Args:
file (list): La file dont l'élément de tête doit être retiré.
Returns:
list: La file sans le premier élément.
"""
return file[1:]
def peak(file: list):
"""
Renvoie l'élément en tête de la file sans le retirer.
Args:
file (list): La file dont on veut consulter le premier élément.
Returns:
L'élément en tête de la file.
"""
return file[0]

5
file/old/file_LSC.py
View File

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

23
file/old/file_tuple.py
View File

@@ -1,23 +0,0 @@
def creer_file_vide():
return ()
def est_vide(file: tuple)-> bool:
return () == file
def tete(file: tuple):
assert not(est_vide(file)), "file vide"
element, reste = file
return element
def queue(file):
element,reste = liste
return reste
def inserer_tete(file,elt):
return (elt,file)
def inserer_queue(file,elt):
if est_vide(file):
return inserer_tete(file,elt)
return inserer_tete(inserer_queu(queue(file),elt)tete(file))

40
prep/dicho.py
View File

@@ -1,40 +0,0 @@
def insertion_sort(liste, ordre):
for i in range(1, len(liste)):
key = liste[i]
j = i - 1
while j >= 0 and ordre(liste[j], key) == -1:
liste[j + 1] = liste[j]
j -= 1
liste[j + 1] = key
return liste
def ordre(a,b):
if a>b:
return -1
elif a<b:
return 1
else:
return 0
if __name__ == "__main__":
l1 = [2,1,6,5,4,7,6,3,2]
insertion_sort(l1,ordre=None)
print(l1)
def dichotomie(liste,ordre,element):
gauche = 0
droite = len(liste)
while (droite - gauche)-1:
millieu = (gauche + droite) //2
if ordre(liste[millieu],element)//2 ==0:
gauche, droite = millieu, milleu +1
elif ordre(liste[millieu],element) == -1:
droite = millieu
else:
gauche = millieu+1
if gauche-droite > 0 and liste[gauche] = element:
return gauche
else:
return -1

2
programmation_dynamique/bag/main.py
View File

@@ -126,9 +126,7 @@ def sac_a_dos_dynamique(videos, capacite):
if __name__ == "__main__":
# Conversion du dictionnaire des vidéos en liste
liste_videos = dico_vers_liste(Videos)
# Affichage de contrôle
for video in liste_videos:
print(video)
opt_brut, dur_brut, taille_brut = sac_a_dos_force_brute(liste_videos, 5.0)

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

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

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

@@ -1,42 +0,0 @@
import sys, pygame
import balle
from constantes import *
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")
clock = pygame.time.Clock()
b1 = balle.Balle()
bouge = False
while True: # Demarrage de la boucle infinie
for event in pygame.event.get():
if event.type == pygame.QUIT: # Evt de sortie de boucle
sys.exit()
elif event.type == pygame.MOUSEBUTTONDOWN and event.button == 1:
bouge = not bouge
elif event.type == pygame.KEYDOWN and event.key == pygame.K_SPACE:
bouge = not bouge
ecran.fill(BLANC)
b1.deplace()
b1.affiche(ecran)
pygame.display.update()
ecran.fill(BLANC)
if bouge:
b1.deplace()
b1.affiche(ecran)
pygame.display.update() # rafraichissement
clock.tick(60)
if __name__ == "__main__":
b1 = balle.Balle()

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

@@ -1,43 +0,0 @@
import sys, pygame
import balle
import raquette
from constantes import *
pygame.init()
# Creation de la fenetre
ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
# Titre de la fenetre
pygame.display.set_caption("Casse_Brique")
clock = pygame.time.Clock()
b1 = balle.Balle()
r1 = raquette.Raquette()
bouge = False
bouge_gauche_raquette = False
bouge_droite_raquette = False
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:
bouge = not bouge
if pygame.key.get_pressed()[pygame.K_q]:
r1.deplaceGauche()
if pygame.key.get_pressed()[pygame.K_d]:
r1.deplaceDroite()
ecran.fill(BLANC)
if bouge:
b1.deplace(r1)
b1.deplace(r1)
b1.affiche(ecran)
r1.affiche(ecran)
pygame.display.update()
clock.tick(60)

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

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

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

@@ -1,59 +0,0 @@
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
"""
def __init__(self):
self.largeur = 100
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)
"""
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)
"""
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)
)
if __name__ == "__main__":
pass

41
pygame/bouncing_ball/ball.py
View File

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

24
pygame/bouncing_ball/balle.py
View File

@@ -1,24 +0,0 @@
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
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

4
pygame/bouncing_ball/constantes.py
View File

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

53
pygame/bouncing_ball/f
View File

@@ -1,53 +0,0 @@
───────┬──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
│ File: raquette.py
───────┼──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────
 1 │ import sys
 2 │ import pygame
 3 │ from balle import Balle
 4 │ from raquette import Raquette
 5 │ from constantes import *
 6 │
 7 │ pygame.init()
 8 │
 9 │ # Création de la fenêtre
 10 │ ecran = pygame.display.set_mode((LARGEUR_ECRAN, HAUTEUR_ECRAN))
 11 │ ecran.fill(BLANC)
 12 │ pygame.display.set_caption('Balle rebondissante avec raquette')
 13 │
 14 │ clock = pygame.time.Clock()
 15 │
 16 │ # Initialisation des objets
 17 │ balle = Balle()
 18 │ raquette = Raquette()
 19 │
 20 │ bouge = False
 21 │
 22 │ while True: # Boucle principale
 23 │  for event in pygame.event.get():
 24 │  if event.type == pygame.QUIT:
 25 │  sys.exit()
 26 │  elif event.type == pygame.KEYDOWN:
 27 │  if event.key == pygame.K_SPACE:
 28 │  bouge = not bouge
 29 │  elif event.key == pygame.K_LEFT:
 30 │  raquette.deplaceGauche()
 31 │  elif event.key == pygame.K_RIGHT:
 32 │  raquette.deplaceDroite()
 33 │
 34 │  ecran.fill(BLANC)
 35 │
 36 │  if bouge:
 37 │  balle.deplace()
 38 │
 39 │  # Collision balle-raquette
 40 │  if (balle.ypos + balle.rayon >= HAUTEUR_ECRAN - 20 and
 41 │  raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur):
 42 │  balle.yvit = -balle.yvit
 43 │
 44 │  balle.affiche(ecran)
 45 │  raquette.affiche(ecran)
 46 │
 47 │  pygame.display.update()
 48 │  clock.tick(60)
 49 │
───────┴──────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────

50
pygame/bouncing_ball/raquette.py
View File

@@ -1,50 +0,0 @@
import sys
import pygame
from balle import Balle
from raquette import Raquette
from constantes import *
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")
clock = pygame.time.Clock()
# Initialisation des objets
balle = Balle()
raquette = Raquette()
bouge = False
while True: # Boucle principale
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
bouge = not bouge
elif event.key == pygame.K_LEFT:
raquette.deplaceGauche()
elif event.key == pygame.K_RIGHT:
raquette.deplaceDroite()
ecran.fill(BLANC)
if bouge:
balle.deplace()
# Collision balle-raquette
if (
balle.ypos + balle.rayon >= HAUTEUR_ECRAN - 20
and raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur
):
balle.yvit = -balle.yvit
balle.affiche(ecran)
raquette.affiche(ecran)
pygame.display.update()
clock.tick(60)

41
pygame/bouncing_ball_project/ball.py
View File

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

35
pygame/bouncing_ball_project/balle.py
View File

@@ -1,35 +0,0 @@
import pygame
import pygame
class Balle:
"""
Definie une balle qui se deplace dans la fenetre ecran
Attributs : rayon , xpos , ypos , xvit , yvit
Methodes : deplace , affiche
"""
def __init__(self):
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
if self.ypos + self.rayon > 800 or self.ypos - self.rayon < 0:
self.yvit = -self.yvit
def affiche(self, ecran):
"""
Dessine la balle sur l'écran
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
)

50
pygame/bouncing_ball_project/bouncing_ball_game.py
View File

@@ -1,50 +0,0 @@
import sys
import pygame
from balle import Balle
from raquette import Raquette
from constantes import *
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")
clock = pygame.time.Clock()
# Initialisation des objets
balle = Balle()
raquette = Raquette()
bouge = False
while True: # Boucle principale
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
if event.key == pygame.K_SPACE:
bouge = not bouge
elif event.key == pygame.K_LEFT:
raquette.deplaceGauche()
elif event.key == pygame.K_RIGHT:
raquette.deplaceDroite()
ecran.fill(BLANC)
if bouge:
balle.deplace()
# Collision balle-raquette
if (
balle.ypos + balle.rayon >= HAUTEUR_ECRAN - 20
and raquette.xpos <= balle.xpos <= raquette.xpos + raquette.largeur
):
balle.yvit = -balle.yvit
balle.affiche(ecran)
raquette.affiche(ecran)
pygame.display.update()
clock.tick(60)

4
pygame/bouncing_ball_project/constantes.py
View File

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

43
pygame/bouncing_ball_project/raquette.py
View File

@@ -1,43 +0,0 @@
import pygame
from constantes import *
class Raquette:
"""
Définit une raquette qui se déplace horizontalement
dans le bas de la fenêtre écran.
Attributs : largeur (int, par défaut 100),
xpos (int, par défaut LARGEUR_ECRAN//2 - largeur//2),
vit (int, par défaut 6)
L'épaisseur de la raquette est de 10.
Méthodes : deplaceGauche, deplaceDroite, affiche
"""
def __init__(self):
self.largeur = 100
self.xpos = LARGEUR_ECRAN // 2 - self.largeur // 2
self.vit = 6
def deplaceGauche(self):
"""
Déplace la raquette vers la gauche si possible.
"""
self.xpos = max(0, self.xpos - self.vit)
def deplaceDroite(self):
"""
Déplace la raquette vers la droite si possible.
"""
self.xpos = min(LARGEUR_ECRAN - self.largeur, self.xpos + self.vit)
def affiche(self, ecran):
"""
Dessine la raquette sur l'écran.
"""
pygame.draw.rect(
ecran, (0, 0, 255), (int(self.xpos), HAUTEUR_ECRAN - 20, self.largeur, 10)
)
if __name__ == "__main__":
pass

27
pygame/jeu/jeu.py
View File

@@ -1,27 +0,0 @@
from pygame.jeu import niveau
class Jeu:
def __init__(self) -> None:
self.niveau = niveau.Niveau()
self.vie = 3
self.bouge = False
self.etat = 1
def gereJeu(self,ecran):
if self.etat == 1:
pass
elif self.etat == 2:
for event in pygame.event.get():
if event.type() == pygame.QUIT:
sys.exit
elif event.type == pygame.MOUSEBUTTONDOWN:
self.bouge = True
else:
self.bouge = True
niveau.affiche(ecran)
if self.bouge:
self.etat = 1
return 1
elif self.etat == 2:
self.etat = niveau.

14
pygame/jeu/niveau.py
View File

@@ -1,14 +0,0 @@
class Niveau:
def __init__(self) -> None:
self.b1 = balle.Balle()
self.r1 = raquette.Raquette()
self.m1 = murdebrique.Wall()
def affiche(self,ecran):
ecran.fill(BLANC)
self.b1.affiche(ecran)
self.r1.affiche(ecran)
self.m1.affiche(ecran)
def levelmanager():
for event in pygame.

163
pygame/lab_py/main.py
View File

@@ -1,163 +0,0 @@
import pygame
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
WIDTH = COLS * CELL_SIZE
HEIGHT = ROWS * CELL_SIZE
# Couleurs
BLACK = (0, 0, 0)
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.visited = False
def draw(self, surface):
"""Dessine la cellule et ses murs sur la surface donnée."""
x = self.i * CELL_SIZE
y = self.j * CELL_SIZE
# Remplir la cellule (si visitée) AVANT de dessiner les murs
if self.visited:
pygame.draw.rect(surface, GRAY, (x, y, CELL_SIZE, CELL_SIZE))
# Dessiner les murs par-dessus la couleur de fond
if self.walls["top"]:
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"]:
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 = []
i, j = cell.i, cell.j
# Voisin du haut
top = get_cell(i, j - 1)
if top and not top.visited:
neighbors.append(top)
# Voisin de droite
right = get_cell(i + 1, j)
if right and not right.visited:
neighbors.append(right)
# Voisin du bas
bottom = get_cell(i, j + 1)
if bottom and not bottom.visited:
neighbors.append(bottom)
# Voisin de gauche
left = get_cell(i - 1, j)
if left and not left.visited:
neighbors.append(left)
return neighbors
def remove_walls(current, next_cell):
"""
Enlève les murs entre la cellule courante et le voisin sélectionné.
"""
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
elif dx == -1: # Voisin à gauche
current.walls["left"] = False
next_cell.walls["right"] = False
elif dy == 1: # Voisin en bas
current.walls["bottom"] = False
next_cell.walls["top"] = False
elif dy == -1: # Voisin en haut
current.walls["top"] = False
next_cell.walls["bottom"] = False
def main():
global grid
pygame.init()
screen = pygame.display.set_mode((WIDTH, HEIGHT))
pygame.display.set_caption("Labyrinthe généré par DFS")
clock = pygame.time.Clock()
# Création de la grille : une matrice de cellules
grid = [[Cell(i, j) for j in range(ROWS)] for i in range(COLS)]
# Initialisation de l'algorithme DFS
current = grid[0][0] # Départ en haut à gauche
current.visited = True
stack = []
running = True
finished = False # Indique si la génération est terminée
while running:
clock.tick(60) # Limite à 60 images par seconde
for event in pygame.event.get():
if event.type == pygame.QUIT:
running = False
# Exécution de l'algorithme DFS tant que la génération n'est pas terminée
if not finished:
neighbors = get_unvisited_neighbors(current)
if neighbors:
# Choix aléatoire d'un voisin non visité
next_cell = random.choice(neighbors)
stack.append(current)
remove_walls(current, next_cell)
current = next_cell
current.visited = True
elif stack:
# Revenir en arrière si aucun voisin n'est disponible
current = stack.pop()
else:
# Génération terminée
finished = True
# Affichage
screen.fill(BLACK)
# Dessiner toutes les cellules de la grille
for i in range(COLS):
for j in range(ROWS):
grid[i][j].draw(screen)
# Mettre en évidence la cellule courante (seulement si la génération est en cours)
if not finished:
x = current.i * CELL_SIZE
y = current.j * CELL_SIZE
pygame.draw.rect(screen, GREEN, (x, y, CELL_SIZE, CELL_SIZE))
pygame.display.flip()
pygame.quit()
sys.exit()
if __name__ == "__main__":
main()

26
question_du_jour/pro_dynamique.py Normal file
View File

@@ -0,0 +1,26 @@
pyramide = [["x"], ["y", "z"], ["a", "b", "c"]]
# tableau triangulaire meilleur rendement avec un double boucle
# exemple:
# [1],[4,2],[9,7,3],[10,6,100,1]
# meilleur chemin 100, 7, 4, 1 (on ne peut pas faire 100 9 4 1 car 100 et 9 sont eloigner d'une distance > 1 au niveau de l'abcisse dans les étages)
def meilleur_rendement(pyramide: list[list[int]]):
copie_l = [ligne for ligne in pyramide[::-1]]
pyramide = pyramide[::-1]
for i in range(1, len(pyramide)):
for j in range(len(pyramide[i])):
pyramide[i][j] += max(pyramide[i - 1][j], pyramide[i - 1][j + 1])
return pyramide[-1][0]
def print_pyramide(pyramide):
for l in pyramide:
print(f"{l}\n")
return None
if __name__ == "__main__":
pyramide1 = [[1], [4, 2], [9, 7, 3], [10, 6, 100, 1]]
print_pyramide(pyramide1[::-1])
print(meilleur_rendement(pyramide1))

54
turing/bitab.py
View File

@@ -1,54 +0,0 @@
class Tableau:
def __init__(self, gauche, droite):
self.gauche = gauche
self.droite = droite
def imin(self):
return -len(self.gauche)
def imax(self):
return len(self.droite) - 1
def append(self, elt):
self.droite.append(elt)
def prepend(self, elt):
self.gauche.append(elt)
def __getitem__(self, i):
if i < 0:
try:
return self.gauche[i]
except IndexError:
print(f"erreur lors de l'index")
else:
try:
return self.droite[i]
except IndexError:
print("error")
def __setitem__(self, i, v):
if i < 0:
try:
self.gauche[i] = v
except IndexError:
print("error")
else:
try:
self.droite[i] = v
except IndexError:
print("error")
def __str__(self) -> str:
string = "|"
for i in self.gauche:
string += str(i) + "|"
for i in self.droite:
string += str(i) + "|"
return string
if __name__ == "__main__":
tab = Tableau([1, 2], [3, 4])
tab.prepend(5)
print(tab.__str__())

62
turing/machine.py
View File

@@ -1,62 +0,0 @@
class Tape:
def __init__(self, input_str: str):
self.tape = list(input_str)
self.head = 0
def read(self):
if self.head < 0:
self.tape = ["•"] * (-self.head) + self.tape
self.head = 0
elif self.head >= len(self.tape):
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":
self.head -= 1
elif direction == "d":
self.head += 1
def __str__(self):
tape_str = "".join(self.tape)
pointer = " " * self.head + "^"
return f"{tape_str}\n{pointer}"
class TuringMachine:
def __init__(self, transitions, initial_state, final_state):
self.transitions = transitions
self.state = initial_state
self.final_state = final_state
def run(self, input_str):
tape = Tape(input_str)
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]
):
print("No transition rule found. Halting.")
break
write_symbol, direction, next_state = self.transitions[self.state][
current_symbol
]
tape.write(write_symbol)
tape.move(direction)
self.state = next_state
steps += 1
print(f"Étape {steps} - État: {self.state}")
print(tape)
print("Machine arrêtée.")
transitions = {
"init": {"1": ("1", "d", "init"), "0": ("0", "d", "init"), "•": ("1", "g", "end")}
}
tm = TuringMachine(transitions, initial_state="init", final_state="end")
tm.run("1011")

21
turing/mc.py
View File

@@ -1,21 +0,0 @@
import bitab as Tabidir
import exemples
class Configuration:
def __init__(self, ruban,position, etat_courant):
self.ruban = ruban
self.position = position:wq
self.etat_courant = etat_courant
def _str__(self):
chaine = ' '
chaine = chaine +(self.position-ruban.imin())*2*' '+self.etat_courant
chaine = chaine + ' '+ (self.position+ruban.imin()*2*' '+ '|'+'\n')
chaine = chaine+self.ruban.__str__()
return chaine
if __name__ == "__main__":
ruban = Tabidir
class Machine: