diff --git a/file/old/LSC.py b/file/old/LSC.py deleted file mode 100644 index 09ec56c..0000000 --- a/file/old/LSC.py +++ /dev/null @@ -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 - - -# ############################################################################ diff --git a/file/old/file.py b/file/old/file.py deleted file mode 100644 index bacf408..0000000 --- a/file/old/file.py +++ /dev/null @@ -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] diff --git a/file/old/file_LSC.py b/file/old/file_LSC.py deleted file mode 100644 index e180bc3..0000000 --- a/file/old/file_LSC.py +++ /dev/null @@ -1,5 +0,0 @@ -import LSC as lifo - - -def creer_liste_vide(): - return lifo.cr diff --git a/file/old/file_tuple.py b/file/old/file_tuple.py deleted file mode 100644 index 2420266..0000000 --- a/file/old/file_tuple.py +++ /dev/null @@ -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)) diff --git a/prep/dicho.py b/prep/dicho.py deleted file mode 100644 index 3695700..0000000 --- a/prep/dicho.py +++ /dev/null @@ -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 0 and liste[gauche] = element: - return gauche - else: - return -1 - diff --git a/programmation_dynamique/bag/main.py b/programmation_dynamique/bag/main.py index b616108..4208834 100644 --- a/programmation_dynamique/bag/main.py +++ b/programmation_dynamique/bag/main.py @@ -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) diff --git a/pygame/V2/balle/balle.py b/pygame/V2/balle/balle.py deleted file mode 100755 index e3849db..0000000 --- a/pygame/V2/balle/balle.py +++ /dev/null @@ -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 diff --git a/pygame/V2/balle/balle_rebondissante.py b/pygame/V2/balle/balle_rebondissante.py deleted file mode 100755 index 76a273e..0000000 --- a/pygame/V2/balle/balle_rebondissante.py +++ /dev/null @@ -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() diff --git a/pygame/V2/balle/casse_brique.py b/pygame/V2/balle/casse_brique.py deleted file mode 100755 index c98deb4..0000000 --- a/pygame/V2/balle/casse_brique.py +++ /dev/null @@ -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) diff --git a/pygame/V2/balle/constantes.py b/pygame/V2/balle/constantes.py deleted file mode 100755 index 4619cab..0000000 --- a/pygame/V2/balle/constantes.py +++ /dev/null @@ -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) diff --git a/pygame/V2/balle/raquette.py b/pygame/V2/balle/raquette.py deleted file mode 100755 index 2e2bba6..0000000 --- a/pygame/V2/balle/raquette.py +++ /dev/null @@ -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 diff --git a/pygame/bouncing_ball/ball.py b/pygame/bouncing_ball/ball.py deleted file mode 100644 index 55b2041..0000000 --- a/pygame/bouncing_ball/ball.py +++ /dev/null @@ -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) diff --git a/pygame/bouncing_ball/balle.py b/pygame/bouncing_ball/balle.py deleted file mode 100644 index 4bd376a..0000000 --- a/pygame/bouncing_ball/balle.py +++ /dev/null @@ -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 diff --git a/pygame/bouncing_ball/constantes.py b/pygame/bouncing_ball/constantes.py deleted file mode 100644 index 5df050b..0000000 --- a/pygame/bouncing_ball/constantes.py +++ /dev/null @@ -1,4 +0,0 @@ -LARGEUR_ECRAN = 600 -HAUTEUR_ECRAN = 800 - -BLANC = (255, 255, 255) diff --git a/pygame/bouncing_ball/f b/pygame/bouncing_ball/f deleted file mode 100644 index 80d88c8..0000000 --- a/pygame/bouncing_ball/f +++ /dev/null @@ -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 │ -───────┴────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────── diff --git a/pygame/bouncing_ball/raquette.py b/pygame/bouncing_ball/raquette.py deleted file mode 100644 index cb85f9e..0000000 --- a/pygame/bouncing_ball/raquette.py +++ /dev/null @@ -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) diff --git a/pygame/bouncing_ball_project/ball.py b/pygame/bouncing_ball_project/ball.py deleted file mode 100644 index 55b2041..0000000 --- a/pygame/bouncing_ball_project/ball.py +++ /dev/null @@ -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) diff --git a/pygame/bouncing_ball_project/balle.py b/pygame/bouncing_ball_project/balle.py deleted file mode 100644 index 14d990c..0000000 --- a/pygame/bouncing_ball_project/balle.py +++ /dev/null @@ -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 - ) diff --git a/pygame/bouncing_ball_project/bouncing_ball_game.py b/pygame/bouncing_ball_project/bouncing_ball_game.py deleted file mode 100644 index cb85f9e..0000000 --- a/pygame/bouncing_ball_project/bouncing_ball_game.py +++ /dev/null @@ -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) diff --git a/pygame/bouncing_ball_project/constantes.py b/pygame/bouncing_ball_project/constantes.py deleted file mode 100644 index 5df050b..0000000 --- a/pygame/bouncing_ball_project/constantes.py +++ /dev/null @@ -1,4 +0,0 @@ -LARGEUR_ECRAN = 600 -HAUTEUR_ECRAN = 800 - -BLANC = (255, 255, 255) diff --git a/pygame/bouncing_ball_project/raquette.py b/pygame/bouncing_ball_project/raquette.py deleted file mode 100644 index aa23a77..0000000 --- a/pygame/bouncing_ball_project/raquette.py +++ /dev/null @@ -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 diff --git a/pygame/jeu/jeu.py b/pygame/jeu/jeu.py deleted file mode 100644 index 1126d47..0000000 --- a/pygame/jeu/jeu.py +++ /dev/null @@ -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. diff --git a/pygame/jeu/niveau.py b/pygame/jeu/niveau.py deleted file mode 100644 index 11e9dd5..0000000 --- a/pygame/jeu/niveau.py +++ /dev/null @@ -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. diff --git a/pygame/lab_py/main.py b/pygame/lab_py/main.py deleted file mode 100644 index fb401d5..0000000 --- a/pygame/lab_py/main.py +++ /dev/null @@ -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() diff --git a/question_du_jour/pro_dynamique.py b/question_du_jour/pro_dynamique.py new file mode 100644 index 0000000..3619c01 --- /dev/null +++ b/question_du_jour/pro_dynamique.py @@ -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)) diff --git a/turing/bitab.py b/turing/bitab.py deleted file mode 100644 index b513d50..0000000 --- a/turing/bitab.py +++ /dev/null @@ -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__()) diff --git a/turing/machine.py b/turing/machine.py deleted file mode 100644 index 536faef..0000000 --- a/turing/machine.py +++ /dev/null @@ -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") diff --git a/turing/mc.py b/turing/mc.py deleted file mode 100644 index 6e3a35f..0000000 --- a/turing/mc.py +++ /dev/null @@ -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: