Dictionnaires en Python + proposition correction automates de Wolfram

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)