=== GESTIONE PARCHEGGIO MULTILIVELLO ===

PARCHEGGIO MULTILIVELLO
🟩 = libero, 🚗 = auto, 🚚 = furgone
------------------------------------------------------------
Livello 0: 🟩 🟩 🚗 🚗 🚗 🟩 🚚 🟩 🚚 🟩 🚚 🟩 🟩 🟩 🚗 🚗 🟩 🚗 🚚 🚗 
Livello 1: 🚗 🟩 🟩 🟩 🟩 🚗 🚗 🟩 🚗 🚚 🟩 🚗 🚗 🟩 🚗 🚗 🟩 🚚 🚗 🟩 
Livello 2: 🚗 🟩 🟩 🚗 🚗 🚚 🚗 🟩 🚗 🚗 🟩 🟩 🟩 🚗 🟩 🚚 🟩 🚗 🚗 🚚 

1. Livello con più posti liberi: livello 0 con 9 posti liberi
2. Furgoni totali nel parcheggio: 9

3. Ricerca 3 posti liberi consecutivi per camper:
  Livello 0: TROVATI ai posti 11, 12, 13
  Livello 1: TROVATI ai posti 1, 2, 3
  Livello 2: TROVATI ai posti 10, 11, 12

4. Statistiche dettagliate:
  Livello 0: 9 liberi, 7 auto, 4 furgoni
  Livello 1: 9 liberi, 9 auto, 2 furgoni
  Livello 2: 8 liberi, 9 auto, 3 furgoni

Spiegazione:

1. Rappresentazione stati diversi: Usiamo costanti numeriche per rappresentare stati diversi (0, 1, 2) per maggiore leggibilità.

2. Conteggio elementi: Il metodo .count(valore) di Python conta le occorrenze di un valore in una lista.

3. Ricerca pattern: Cercare posti consecutivi liberi significa cercare una sequenza di zeri di lunghezza specificata.

4. Scansione sequenziale: Scorriamo il livello e per ogni posizione controlliamo le n posizioni successive.

💡 Osservazione:

L’algoritmo di ricerca di n posti consecutivi liberi ha complessità O(m×n) dove m è la lunghezza della lista. Potremmo ottimizzarlo usando una finestra scorrevole che mantiene il conteggio dei posti liberi nella finestra corrente.

Il codice che abbiamo scritto funziona per un parcheggio di 60 posti. Ma se i posti fossero 600.000? Qui entra in gioco la necessità di librerie come NumPy. In produzione, non useremmo liste di liste, ma array multidimensionali ottimizzati per la velocità della CPU.

Domanda di riflessione: Come potresti modificare trova_posti_consecutivi per trovare il PRIMO insieme di posti liberi consecutivi, piuttosto che fermarti al primo trovato?

Esercizio 2: Gioco del Campo Minato (Livello Intermedio-Avanzato)

Testo: Implementa una versione semplificata del campo minato. Data una matrice 6×6 che rappresenta un campo, dove 0 = sicuro e 1 = mina:

1. Genera un campo con il 20% di mine

2. Crea una seconda matrice che per ogni cella calcoli quante mine ci sono nelle 8 celle adiacenti

3. Implementa una funzione per rivelare una cella: se è una mina, game over; altrimenti mostra il numero di mine adiacenti

Soluzione

import random

# 1. Generazione campo minato
def genera_campo(righe=6, colonne=6, probabilita_mina=0.2):
    """
    Crea una matrice campo minato con probabilità data di mine.
    """
    campo = []
    for i in range(righe):
        riga = []
        for j in range(colonne):
            if random.random() < probabilita_mina:
                riga.append(1)  # Mina
            else:
                riga.append(0)  # Sicuro
        campo.append(riga)
    return campo

# 2. Calcolo mine adiacenti
def calcola_adiacenti(campo):
    """
    Crea una matrice con il conteggio delle mine nelle 8 celle adiacenti.
    """
    righe = len(campo)
    colonne = len(campo[0])
    adiacenti = []
    
    for i in range(righe):
        riga_adiacenti = []
        for j in range(colonne):
            # Se la cella è una mina, metti -1 (per indicare mina)
            if campo[i][j] == 1:
                riga_adiacenti.append(-1)
            else:
                # Conta mine nelle 8 celle adiacenti
                conteggio = 0
                
                # Itera sulle 8 direzioni: (-1,-1), (-1,0), (-1,1), ...
                for di in [-1, 0, 1]:
                    for dj in [-1, 0, 1]:
                        # Salta la cella stessa
                        if di == 0 and dj == 0:
                            continue
                        
                        ni, nj = i + di, j + dj
                        
                        # Controlla se la cella adiacente è dentro i bordi
                        if 0 <= ni < righe and 0 <= nj < colonne:
                            if campo[ni][nj] == 1:
                                conteggio += 1
                
                riga_adiacenti.append(conteggio)
        adiacenti.append(riga_adiacenti)
    
    return adiacenti

# 3. Funzione per rivelare una cella
def rivelacella(campo, adiacenti, i, j):
    """
    Rivela una cella del campo minato.
    Restituisce: True se è una mina (game over), False altrimenti.
    """
    if campo[i][j] == 1:
        return True  # Mina! Game over
    else:
        return False  # Sicuro

# 4. Visualizzazione
def visualizza_gioco(campo, adiacenti, rivelate):
    """
    Visualizza lo stato corrente del gioco.
    """
    righe = len(campo)
    colonne = len(campo[0])
    
    print("   " + " ".join(str(j) for j in range(colonne)))
    print("  +" + "-" * (2*colonne))
    
    for i in range(righe):
        print(f"{i} |", end=" ")
        for j in range(colonne):
            if (i, j) in rivelate:
                if campo[i][j] == 1:
                    print("💣", end=" ")
                else:
                    num = adiacenti[i][j]
                    if num == 0:
                        print("·", end=" ")
                    else:
                        print(num, end=" ")
            else:
                print("■", end=" ")
        print()

# ESECUZIONE PRINCIPALE
print("=== CAMPO MINATO ===\n")

# Genera campo
campo = genera_campo(6, 6, 0.2)
adiacenti = calcola_adiacenti(campo)
rivelate = set()  # Insieme di celle già rivelate
game_over = False

print("Campo iniziale (■ = nascosto):")
visualizza_gioco(campo, adiacenti, rivelate)

# Simulazione di gioco
print("\n--- SIMULAZIONE DI GIOCO ---")

# Mosse di esempio
mosse = [(0, 0), (2, 2), (1, 1), (3, 3)]

for mossa_idx, (i, j) in enumerate(mosse):
    if game_over:
        break
    
    print(f"\nMossa {mossa_idx+1}: rivela cella ({i}, {j})")
    
    if rivelacella(campo, adiacenti, i, j):
        print("BOOM! Hai trovato una mina! Game Over!")
        game_over = True
    else:
        print(f"Sicuro! Ci sono {adiacenti[i][j]} mine adiacenti.")
        rivelate.add((i, j))
    
    visualizza_gioco(campo, adiacenti, rivelate)

# Mostra il campo completo alla fine
if game_over or mossa_idx == len(mosse) - 1:
    print("\n--- CAMPO COMPLETO (tutte le mine rivelate) ---")
    tutte_rivelate = [(i, j) for i in range(6) for j in range(6)]
    visualizza_gioco(campo, adiacenti, tutte_rivelate)

# Statistiche
print("\n--- STATISTICHE ---")
mine_totali = sum(sum(riga) for riga in campo)
print(f"Mine totali nel campo: {mine_totali}")
print(f"Celle rivelate: {len(rivelate)}")
print(f"Celle sicure rivelate: {sum(1 for (i,j) in rivelate if campo[i][j] == 0)}")

=== CAMPO MINATO ===

Campo iniziale (■ = nascosto):
   0 1 2 3 4 5
  +------------
0 | ■ ■ ■ ■ ■ ■ 
1 | ■ ■ ■ ■ ■ ■ 
2 | ■ ■ ■ ■ ■ ■ 
3 | ■ ■ ■ ■ ■ ■ 
4 | ■ ■ ■ ■ ■ ■ 
5 | ■ ■ ■ ■ ■ ■ 

--- SIMULAZIONE DI GIOCO ---

Mossa 1: rivela cella (0, 0)
BOOM! Hai trovato una mina! Game Over!
   0 1 2 3 4 5
  +------------
0 | ■ ■ ■ ■ ■ ■ 
1 | ■ ■ ■ ■ ■ ■ 
2 | ■ ■ ■ ■ ■ ■ 
3 | ■ ■ ■ ■ ■ ■ 
4 | ■ ■ ■ ■ ■ ■ 
5 | ■ ■ ■ ■ ■ ■ 

--- CAMPO COMPLETO (tutte le mine rivelate) ---
   0 1 2 3 4 5
  +------------
0 | 💣 1 · 1 💣 1 
1 | 2 2 1 2 2 2 
2 | 1 💣 2 3 💣 2 
3 | 2 3 💣 4 💣 3 
4 | 💣 3 2 4 💣 2 
5 | 1 2 💣 2 1 1 

--- STATISTICHE ---
Mine totali nel campo: 9
Celle rivelate: 0
Celle sicure rivelate: 0

def trova_tutti_posti_consecutivi(livello, consecutivi=3):
    posizioni = []
    for i in range(len(livello) - consecutivi + 1):
        tutti_liberi = True
        for j in range(consecutivi):
            if livello[i + j] != LIBERO:
                tutti_liberi = False
                break
        if tutti_liberi:
            posizioni.append(i)
    return posizioni

def calcola_adiacenti_toroidali(campo):
    righe = len(campo)
    colonne = len(campo[0])
    adiacenti = []
    
    for i in range(righe):
        riga_adiacenti = []
        for j in range(colonne):
            if campo[i][j] == 1:
                riga_adiacenti.append(-1)
            else:
                conteggio = 0
                for di in [-1, 0, 1]:
                    for dj in [-1, 0, 1]:
                        if di == 0 and dj == 0:
                            continue
                        # Usa modulo per gestire bordi toroidali
                        ni = (i + di) % righe
                        nj = (j + dj) % colonne
                        if campo[ni][nj] == 1:
                            conteggio += 1
                riga_adiacenti.append(conteggio)
        adiacenti.append(riga_adiacenti)
    
    return adiacenti