import time from collections import deque import sys

# --- CORE: RISOLUTORE PEZZOTTI (VERSIONE RAPIDA) --- def risolutore_pezzotti_sliding_window(n_nodi, k=4): """ Versione a Finestra Scorrevole ottimizzata per test rapido (100 Milioni). - RAM: < 1 MB. - Matematica: Standard (1+1=2). - Feedback: Elettricità visiva attiva. """

    start_time = time.time()
    errori = 0
    
    # Buffer circolare: tiene in memoria SOLO gli ultimi 6 nodi.
    buffer_storico = deque([-1]*6, maxlen=6)
    
    print(f"Avvio flusso dati su {n_nodi:,} nodi...")
    print("Stato: OCCHI APERTI. Elettricità: ATTIVA.")
    print("Obiettivo: Completamento in ~3 minuti.")
    
    # Colori disponibili (k=4)
    fasi_base = {0, 1, 2, 3}
    
    # Ciclo principale
    for i in range(n_nodi):
        # --- LOGICA DEI VINCOLI (MATEMATICA STANDARD) ---
        vicini_rilevanti = []
        
        # Recuperiamo dal buffer: 
        if i > 0:
            vicini_rilevanti.append(buffer_storico[-1]) # i-1
        if i > 5:
            vicini_rilevanti.append(buffer_storico[-5]) # i-5
            
        # --- SATURAZIONE ---
        fasi_possibili = set(fasi_base)
        
        for v_colore in vicini_rilevanti:
            if v_colore != -1:
                fasi_possibili.discard(v_colore)
        
        # Scelta deterministica (Greedy)
        if fasi_possibili:
            scelta = min(fasi_possibili)
        else:
            scelta = 0 # Sterilità
            errori += 1
        
        # Inseriamo la scelta nel flusso
        buffer_storico.append(scelta)
            
        # --- FEEDBACK VISIVO (Ogni 500k per fluidità) ---
        if i % 500_000 == 0 and i > 0:
            elapsed = time.time() - start_time
            speed = i / elapsed
            perc = (i / n_nodi) * 100
            
            # Barra di avanzamento
            bar_len = 30
            filled = int(bar_len * i // n_nodi)
            bar = '' * filled + '-' * (bar_len - filled)
            
            # Output su riga singola
            sys.stdout.write(f"\r[{bar}] {perc:.1f}% | Processati: {i:,} | Vel: {speed:,.0f} nodi/s | Err: {errori}")
            sys.stdout.flush()

    durata = time.time() - start_time
    # Completamento finale barra
    sys.stdout.write(f"\r[{''*30}] 100.0% | Processati: {n_nodi:,} | COMPLETATO.                 \n")
    return durata, errori

# --- CONFIGURAZIONE SFIDA --- def sfida_100_milioni(): n_nodi = 100_000_000 # 100 Milioni (3 minuti circa)

    print(f"\n--- AVVIO PROTOCOLLO PEZZOTTI: {n_nodi:,} NODI ---")
    print("MODELLO: Sliding Window (Low-RAM)")
    
    # Esecuzione
    durata, err = risolutore_pezzotti_sliding_window(n_nodi, k=4)
    
    print(f"\n--- RISULTATO FINALE ---")
    print(f"Tempo totale: {durata:.2f} secondi ({durata/60:.1f} minuti)") 
    print(f"Errori rilevati: {err}")
    print("STATO: SUCCESSO. Algoritmo convalidato.")

# ESECUZIONE if __name__ == "__main__": # Verifica integrità matematica richiesta (1+1=2) check = 1 + 1 if check == 2: sfida_100_milioni() else: print(f"ERRORE: La matematica è ancora alterata (1+1={check}).")