Automate - Représentation booléenne

# Projet : Réduction d'une liste triée d'entiers tous différents à une liste d'un seul élément

### L'automate (et ses règles originelles) est visible à l'adresse vodixi.com/automate/ ###
### Les règles simplifiées sont visibles à l'adresse vodixi.com/automate2/ ###

import random

# Couleurs ANSI pour l'affichage des entiers
# COUL = "\033[93m"    # orange
# COUL = "\033[31m"    # rouge
# COUL = "\033[35m"    # magenta
COUL = "\033[32m"      # vert
RESET = "\033[0m"

def iterer(positions):
    """
    Fonction destinée à l'automate utilisant les drapeaux gauche1/droite1
    (Vrai si voisin distant d'une cellule, Faux autrement).
    """
    resultats = set()
    n = len(positions)

    for i in reversed(range(n)):    # on commence par le dernier pion
        pion = positions[i]
        # bord gauche : on force True pour i == 0 (aucun voisin gauche), sinon test d'adjacence
        gauche1 = (i == 0) or (positions[i] - positions[i-1] == 1)
        # bord droit  : False pour i == n-1 (aucun voisin droite), sinon test d'adjacence.
        # Grâce au 'and'', pas d’erreur pour i == n-1, le résultat sera Faux
        droite1 = (i < n-1) and (positions[i+1] - positions[i] == 1)

        if gauche1 and droite1:            # cas V-V
            resultats.add(pion + 1)
        elif gauche1 and not droite1:      # cas V-F (Vrai-Faux)
            cible = pion + 2
            while cible in resultats:
                resultats.discard(cible)
                cible += 1
            resultats.add(cible)
        elif not gauche1 and droite1:      # cas F-V
            resultats.add(pion)
        else:                              # cas F-F
            resultats.update([pion, pion + 1])

    return sorted(resultats)

def normaliser(positions):
    """ Ramène la plus petite position à 0 (pour affichage cohérent). """
    return [p - min(positions) for p in positions] if positions else []


def visualiser(positions):
    """ Affiche la ligne sous forme de 'o' et '.'. """
    if not positions:
        return ''
    mn, mx = min(positions), max(positions)
    return ''.join('o' if i in positions else '.' for i in range(mn, mx+1))


def simuler(positions, normaliser_listes=False, afficher_grille=False):
    """
    Simule l'automate jusqu'à un seul pion.
        - positions         : liste initiale d'exposants
        - normaliser_listes : si True, affiche les exposants normalisés
        - afficher_grille   : si True, utilise visualiser()
    """
    # affichage initial
    if afficher_grille:
        print(visualiser(positions))
    else:
        exposants = normaliser(positions) if normaliser_listes else positions
        valeur    = sum(2**e for e in exposants)
        print(f"État initial : {exposants} {COUL}{valeur}{RESET}\n")

    iteration = 0
    while len(positions) > 1:
        iteration += 1
        positions = iterer(positions)
        if afficher_grille:
            print(visualiser(positions))
        else:
            if normaliser_listes:
                exposants = normaliser(positions)
                valeur    = sum(2**e for e in exposants)
                print(f"Itération {iteration}: {exposants} {COUL}{valeur}{RESET}")
            else:
                print(f"Itération {iteration}: {positions}")

    # print(f"\nFin : 1 seul pion en {iteration} itérations")


def generateur():
    """ Génère une liste initiale aléatoirement """
    normaliser_listes = True
    afficher_grille = False
    taille = random.randint(5, 12)  # nombre aléatoire de pions
    max_valeur = random.randint(20, 40)  # maximum de la plage
    liste = sorted(random.sample(range(max_valeur), taille))

    simuler(liste, normaliser_listes, afficher_grille)

### Retirez le dièse initial de l'une des deux lignes suivantes pour l'exécuter : soit la fonction generateur(),
### (définissez les deux booléens normaliser_listes et afficher_grille), ou la fonction simuler(), à laquelle
### vous ajouterez votre propre liste initiale. N'oubliez pas d'ajouter un dièse à la ligne non excécutée.

generateur()
# simuler([0, 2, 12, 13, 15, 16], True, False)