Proposition de correction des automates de Wolfram avec chaînes de caractères et dictionnaire
# automate de Wolfram avec gestion des données sous forme
# de chaînes de caractères
def initialisation(n):
'''
renvoie une chaîne de caractère de longueur n
correspondant à l'étape 0
: n : int ( n > 1 )
: return : une chaîne de caractère
>>> a=initialisation(3)
>>> print(a)
' * '
>>> a=initialisation(5)
>>> print(a)
' * '
'''
retour=""
vide=""
if n%2==0 :
for i in range(n//2-1):
vide+="-"
retour+=vide+"**"+vide
return retour
for i in range(n//2):
vide+="-"
retour+=vide+"*"+vide
return retour
def transcription(regle):
'''
traduit la regle en binaire
: regle : int ( entre 0 et 255 compris )
: retour : chaîne de caractère de longueur 8
>>>print(transcription(0))
--------
>>>print(transcription(2))
------*-
>>>print(transcription(255))
--------
>>>print(transcription(120))
-****---
'''
regle_binaire=bin(regle)
regle_binaire=regle_binaire[2:len(regle_binaire)]
# on ajoute les 0 nécessaire pour obtenir une chaîne
# de 8 caractères
vide=""
for i in range(0,8-len(regle_binaire)):
vide+="0"
regle_binaire=vide+regle_binaire
retour=""
for bit in regle_binaire:
if bit=="0" :
retour+="-"
else :
retour+="*"
return retour
def ecriture_dictionnaire(regle):
'''
traduit l'application de la regle aux différents cas
: regle : str ( chaîne de caractères de longueur 8 )
: return : dict ( dictionnaire )
>>> print(ecriture_dictionnaire('--**--*-'))
{'***': '-', '**-': '-', '*-*': '*', '*--': '*', '-**': '-', '-*-': '-', '--*': '*', '---': '-'}
>>> print(ecriture_dictionnaire('******-*'))
{'***': '*', '**-': '*', '*-*': '*', '*--': '*', '-**': '*', '-*-': '*', '--*': '-', '---': '*'}
'''
retour=dict()
retour['***']=regle[0]
retour['**-']=regle[1]
retour['*-*']=regle[2]
retour['*--']=regle[3]
retour['-**']=regle[4]
retour['-*-']=regle[5]
retour['--*']=regle[6]
retour['---']=regle[7]
return retour
def evolution(situation,regle):
'''
détermine l'évolution d'une situation donnée en fonction
de la règle
: situation : str
: regle : int
>>>situation="--*--**-"
>>>print(evolution(situation,5))
--*-----
'''
regle_bin=transcription(regle)
regle_a_appliquer=ecriture_dictionnaire(regle_bin)
retour="-"
for j in range(1,len(situation)-1):
cases=situation[j-1:j+2]
retour+=regle_a_appliquer[cases]
retour+="-"
return retour
def evolution_finale(longueur,regle,nombre_etapes):
'''
retourne une chaîne de caractère correspondant à l'évolution
selon la regle sur un nombre d'étapes donné d'une situtation
de longueur initiale donnée
: longueur : int ( >0 )
: nombre_etapes: int
: regle : int ( entre 0 et 255 )
: return : un tuple contenant les différentes étapes d'évolution
>>> evolution_finale(41,78,10)
--------------------*--------------------
-------------------**--------------------
------------------***--------------------
-----------------**-*--------------------
----------------***-*--------------------
---------------**-*-*--------------------
--------------***-*-*--------------------
-------------**-*-*-*--------------------
------------***-*-*-*--------------------
'''
evolutions=(initialisation(longueur),)
for j in range(nombre_etapes):
situation=evolutions[-1]
print(situation)
nvl_situation=evolution(situation,regle)
evolutions+=(nvl_situation,)
return evolutions
regle=150
print(ecriture_dictionnaire(transcription(regle)))
evolution_finale(40,regle,10)