177 lines
3.5 KiB
Python
177 lines
3.5 KiB
Python
import os
|
|
os.chdir("/media/eleve/1B2E-2F4E/MPx/")
|
|
from piles import *
|
|
import random
|
|
import labyrinthe as laby
|
|
|
|
|
|
def copie(pile):
|
|
els = Pile()
|
|
out = Pile()
|
|
while not pile.estPileVide():
|
|
els.empiler(pile.depiler())
|
|
while not els.estPileVide():
|
|
x = els.depiler()
|
|
out.empiler(x)
|
|
pile.empiler(x)
|
|
|
|
return out
|
|
|
|
Pile.copie = copie
|
|
|
|
"""
|
|
Complexité temporelle, avec n la longueur de la pile: O(n)
|
|
Complexité spaciale, avec n la taille de la pile: O(n)
|
|
"""
|
|
|
|
def miroir(pile):
|
|
deca = pile.copie()
|
|
out = Pile()
|
|
while not deca.estPileVide():
|
|
out.empiler(deca.depiler())
|
|
return out
|
|
Pile.miroir = miroir
|
|
"""
|
|
O(n)
|
|
O(n)
|
|
"""
|
|
|
|
def taille(pile):
|
|
deca = pile.copie()
|
|
i = 0
|
|
while not deca.estPileVide():
|
|
i+=1
|
|
deca.depiler()
|
|
return i
|
|
Pile.taille = taille
|
|
"""
|
|
O(n)
|
|
O(n)
|
|
"""
|
|
|
|
def nth(pile,n):
|
|
t = pile.taille()
|
|
deca = pile.copie()
|
|
i = 0
|
|
while not deca.estPileVide():
|
|
i+=1
|
|
if i==t-n:
|
|
return deca.depiler()
|
|
deca.depiler()
|
|
raise IndexError("La pile est trop petite !")
|
|
|
|
Pile.nth = nth
|
|
"""
|
|
O(n)
|
|
O(n)
|
|
"""
|
|
|
|
def degringoler(pile):
|
|
if pile.estPileVide():
|
|
raise IndexError("Mais ……… cette pile est vide !")
|
|
x0 = pile.depiler()
|
|
deca = Pile()
|
|
while not pile.estPileVide():
|
|
deca.empiler(pile.depiler())
|
|
pile.empiler(x0)
|
|
while not deca.estPileVide():
|
|
pile.empiler(deca.depiler())
|
|
|
|
Pile.degringoler = degringoler
|
|
"""
|
|
O(exp(42*n)) non, bien sur, c'est du O(n)
|
|
O(n)
|
|
"""
|
|
|
|
def toList(pile):
|
|
deca = pile.copie()
|
|
out=[]
|
|
while not deca.estPileVide():
|
|
out.append(deca.depiler())
|
|
return out
|
|
|
|
Pile.toList = toList
|
|
|
|
|
|
print("----------------------------")
|
|
print("Essai de la (nouvelle) classe pile")
|
|
p = Pile()
|
|
p.empiler(1)
|
|
p.empiler(2)
|
|
print(p)
|
|
p.depiler()
|
|
print(p)
|
|
p.depiler()
|
|
print(p)
|
|
p.empiler('*')
|
|
p.empiler('p')
|
|
p.empiler('m')
|
|
print(p)
|
|
print(p.nth(0))
|
|
print(p.nth(1))
|
|
print(p.nth(2))
|
|
print(p.miroir())
|
|
p.empiler(1)
|
|
print(p)
|
|
print("----------------------------")
|
|
|
|
|
|
|
|
### Labyrinthes
|
|
|
|
def estValide(i,j,n,p):
|
|
return (0<=i and i<n) and (0<=j and j<p)
|
|
|
|
def initList(n,p):
|
|
out = []
|
|
for _ in range(n):
|
|
out.append(p*[False])
|
|
return out
|
|
|
|
def initNList(n,p):
|
|
out = []
|
|
for _ in range(n):
|
|
out.append(p*[None])
|
|
return out
|
|
|
|
def voisins(case,n,p,dejaVu):
|
|
i,j = case
|
|
out = [(i-1,j),(i,j-1),(i,j+1),(i+1,j)]
|
|
return [(i,j) for i,j in out if estValide(i,j,n,p) and not dejaVu[i][j]]
|
|
|
|
def choix(L):
|
|
if(len(L)==0):
|
|
raise IndexError("Un élément du vide ? Je propose néant mais vous n'allez pas aimer.")
|
|
return L[random.randrange(len(L))]
|
|
|
|
def labyrinthe(n,p):
|
|
dejaVu = initList(n,p)
|
|
predecesseur = initNList(n,p)
|
|
pile = Pile()
|
|
pile.empiler((0,0))
|
|
segs = Pile()
|
|
|
|
while not pile.estPileVide():
|
|
caseCourante=pile.depiler()
|
|
vz = voisins(caseCourante,n,p,dejaVu)
|
|
if not len(vz)==0:
|
|
nouvelleCase = choix(vz)
|
|
(inn,jnn) = nouvelleCase
|
|
dejaVu[inn][jnn] = True
|
|
segs.empiler((caseCourante,nouvelleCase))
|
|
predecesseur[inn][jnn] = caseCourante
|
|
pile.empiler(caseCourante)
|
|
pile.empiler(nouvelleCase)
|
|
|
|
return segs.toList(),predecesseur
|
|
def plusCourtParfait(l,pdz,dest):
|
|
path = Pile()
|
|
pile.empile(out)
|
|
whereami = dest
|
|
while
|
|
l,pdz = labyrinthe(100,100)
|
|
|
|
laby.affiche(l,100,100)
|
|
|
|
|