python esercizio Archivi

25 Gennaio 2021 Nessun commento

[python] Semplice esercizio per creare il gioco del campo minato in Python (da console)

In questo semplice esercizio vogliamo riprodurre in Python, in modo un po’ rudimentale, quello che era il gioco del campo minato (poi campo fiorito) per Windows.

Quello che vogliamo ottenere assomiglierà a questo all’avvio:

Mentre alla vittoria otterremo qualcosa di simile:

Il gioco sarà costruito su una griglia 10×10, di 100 caselle in totale, che faremo selezionare all’utente con un numero da 1 a 100.

Anzitutto costruiamo la griglia fatta di oggetti di tipo Casella, definiti nel modo seguente:

class Casella:

    def __init__(s, mina = False):
        s.mina = mina
        s.aperta = False
        s.conteggio = 0

class Casella:

def __init__(s, mina = False):

s.mina = mina

s.aperta = False

s.conteggio = 0

Per costruire il campo useremo la funzione random.randint() per distribuire le mine in modo casuale, nel modo seguente:

campo = [[Casella(True if random.randint(0,difficolta)==0 else False) for j in range(n)] for i in range(n)]

1	campo = [[Casella(True if random.randint(0,difficolta)==0 else False) for j in range(n)] for i in range(n)]

In questo caso la variabile difficolta viene usata per bilanciare la distribuzione casuale. Se impostiamo difficolta su 2, avremo in media il 50% di caselle con mine (1/2). Se impostiamo difficolta su 10 allora avremo circa il 10% di mine (1/10), ecc.

Fatto questo dobbiamo costruire due metodi che si occuperanno rispettivamente di conteggiare le mine e aprire le celle. All’interno di entrambi i metodi useremo due cicli for ricordandoci che rispetto alla posizione attuale quelle intorno partiranno da [-1,-1] fino a [1,1]

Riporto di seguito il codice, commentato, dell’intero giochino realizzato a partire da queste idee:

import random

class Casella:

    def __init__(s, mina = False):
        s.mina = mina
        s.aperta = False
        s.conteggio = 0

def conteggio(i,j):

    global n,campo

    # se nella cella non c'è una mina allora procedi
    if campo[i][j].mina == False:
        # controlliamo le celle tutto intorno
        for di in range(-1,2):
            for dj in range(-1,2):
                # se la posizione è compresa nell'intervallo della matrice
                if (i+di > -1 and j+dj > -1) and (i+di < n and j+dj < n):
                    # se la cella è una mina
                    if campo[i+di][j+dj].mina == True:
                        # incrementiamo il contatore
                        campo[i][j].conteggio += 1
        # sfruttiamo il contatore per conteggiare il numero di mine nel gioco
        # se non abbiamo una mina restituiamo 0
        return 0
    else:
        #se abbiamo invece una mina restituiamo 1
        return 1

def controlla(i,j):

    global n,campo

    # se la cella è aperta non facciamo altro
    #restituiamo True per dire che il gioco continua
    if campo[i][j].aperta: return True

    # impostiamo la cella come aperta
    campo[i][j].aperta = True

    # se non abbiamo una mina e il conteggio è a 0, allora procediamo
    # questo perché, cliccando su una cella, vogliamo aprire tutte le celle vuote
    #che non hanno alcuna mina accanto
    if campo[i][j].mina == False and campo[i][j].conteggio == 0:
        for di in range(-1,2):
            for dj in range(-1,2):
                if (i+di > -1 and j+dj > -1) and (i+di < n and j+dj < n):
                    # se non abbiamo una mina e non siamo sulle celle diagonali
                    # l'apertura avviene solo in orizzontale e verticale
                    if not campo[i+di][j+dj].mina:
                        controlla(i+di,j+dj)
    # altrimenti se abbiamo una mina, restituiamo False
    elif campo[i][j].mina:
        return False
    # in tutti gli altri casi True
    return True

# difficoltà come probabilità di trovare mine, 1 / difficolta
difficolta = 10

while True:

    # stampiamo il menu
    print("-- MENU --")
    print("1. gioca")
    print("2. imposta difficoltà")
    print("0. esci")
    s = int(input("> "))

    # usciamo dal gioco
    if s == 0: break

    # giochiamo
    if s == 1:

        #dimensione del campo
        n = 10
        # disegniamo il campo
        campo = [[Casella(True if random.randint(0,difficolta)==0 else False) for j in range(n)] for i in range(n)]
        # true = continua il gioco, false = si ferma
        risultato = True
        totale_mine = 0

        # conteggiamo le mine rispetto alle caselle e le mine totali
        for i in range(n):
            for j in range(n):
                totale_mine += conteggio(i,j)

        # comincia l'inserimento
        while True:

            # numeri in cima
            print(end=" "*3)
            for i in range(n): print(i+1,end=" ")
            print()

            # conteggio chiuse
            ancora_chiuse = 0
            for nr, r in enumerate(campo):
                # numeri accanto
                print(nr,end=" "*2)
                for c in r:
                    # stampa a video
                    if c.aperta:
                        if c.mina: print("X",end=" ")
                        elif c.conteggio > 0: print(c.conteggio,end=" ")
                        else: print(" ",end=" ")
                    else:
                        if c.mina and not risultato: print("X",end=" ")
                        else:
                            print("-",end=" ")
                            ancora_chiuse += 1
                print()
                
            if not risultato:
                print("hai perso")
                break

            if ancora_chiuse <= totale_mine:
                print("hai vinto!")
                break

            # leggiamo l'input e trasformiamolo nella posizione i,j
            pos = int(input("posizione [1-%d]: " % (n**2)))
            i = int((pos-1)/n)
            j = pos - i*n - 1

            # controlliamo la cella corrente
            risultato = controlla(i,j)

    if s == 2:

        # impostiamo la difficoltà
        d = int(input("seleziona difficoltà (1 = facile, 2 = medio, 3 = difficile): "))
        if d == 1: difficolta = 10
        if d == 2: difficolta = 6
        if d == 3: difficolta = 4

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

import random

class Casella:

def __init__(s, mina = False):

s.mina = mina

s.aperta = False

s.conteggio = 0

def conteggio(i,j):

global n,campo

# se nella cella non c'è una mina allora procedi

if campo[i][j].mina == False:

# controlliamo le celle tutto intorno

for di in range(-1,2):

for dj in range(-1,2):

# se la posizione è compresa nell'intervallo della matrice

if (i+di > -1 and j+dj > -1) and (i+di < n and j+dj < n):

# se la cella è una mina

if campo[i+di][j+dj].mina == True:

# incrementiamo il contatore

campo[i][j].conteggio += 1

# sfruttiamo il contatore per conteggiare il numero di mine nel gioco

# se non abbiamo una mina restituiamo 0

return 0

else:

#se abbiamo invece una mina restituiamo 1

return 1

def controlla(i,j):

global n,campo

# se la cella è aperta non facciamo altro

#restituiamo True per dire che il gioco continua

if campo[i][j].aperta: return True

# impostiamo la cella come aperta

campo[i][j].aperta = True

# se non abbiamo una mina e il conteggio è a 0, allora procediamo

# questo perché, cliccando su una cella, vogliamo aprire tutte le celle vuote

#che non hanno alcuna mina accanto

if campo[i][j].mina == False and campo[i][j].conteggio == 0:

for di in range(-1,2):

for dj in range(-1,2):

if (i+di > -1 and j+dj > -1) and (i+di < n and j+dj < n):

# se non abbiamo una mina e non siamo sulle celle diagonali

# l'apertura avviene solo in orizzontale e verticale

if not campo[i+di][j+dj].mina:

controlla(i+di,j+dj)

# altrimenti se abbiamo una mina, restituiamo False

elif campo[i][j].mina:

return False

# in tutti gli altri casi True

return True

# difficoltà come probabilità di trovare mine, 1 / difficolta

difficolta = 10

while True:

# stampiamo il menu

print("-- MENU --")

print("1. gioca")

print("2. imposta difficoltà")

print("0. esci")

s = int(input("> "))

# usciamo dal gioco

if s == 0: break

# giochiamo

if s == 1:

#dimensione del campo

n = 10

# disegniamo il campo

campo = [[Casella(True if random.randint(0,difficolta)==0 else False) for j in range(n)] for i in range(n)]

# true = continua il gioco, false = si ferma

risultato = True

totale_mine = 0

# conteggiamo le mine rispetto alle caselle e le mine totali

for i in range(n):

for j in range(n):

totale_mine += conteggio(i,j)

# comincia l'inserimento

while True:

# numeri in cima

print(end=" "*3)

for i in range(n): print(i+1,end=" ")

print()

# conteggio chiuse

ancora_chiuse = 0

for nr, r in enumerate(campo):

# numeri accanto

print(nr,end=" "*2)

for c in r:

# stampa a video

if c.aperta:

if c.mina: print("X",end=" ")

elif c.conteggio > 0: print(c.conteggio,end=" ")

else: print(" ",end=" ")

else:

if c.mina and not risultato: print("X",end=" ")

else:

print("-",end=" ")

ancora_chiuse += 1

print()

if not risultato:

print("hai perso")

break

if ancora_chiuse <= totale_mine:

print("hai vinto!")

break

# leggiamo l'input e trasformiamolo nella posizione i,j

pos = int(input("posizione [1-%d]: " % (n**2)))

i = int((pos-1)/n)

j = pos - i*n - 1

# controlliamo la cella corrente

risultato = controlla(i,j)

if s == 2:

# impostiamo la difficoltà

d = int(input("seleziona difficoltà (1 = facile, 2 = medio, 3 = difficile): "))

if d == 1: difficolta = 10

if d == 2: difficolta = 6

if d == 3: difficolta = 4

Vedi articolo

2 Luglio 2020 1 commento

[python] Esercizio su funzioni ricorsive e calcolo del percorso minore possibile

Immaginiamo di avere la seguente situazione: su una griglia rettangolare abbiamo due punti, A e B e vogliamo calcolare il minore percorso possibile per arrivare da A a B, evitando degli ostacoli. Da una cella all’altra ci si può spostare solamente in verticale ed orizzontale.

Possiamo schematizzare il problema in qualcosa di simile.

Anzitutto impostiamo le variabili necessarie:

n = 10 # numero di colonne
m = 10 # numero di righe
x = 10 # numero di ostacoli
pi = [] # punto di partenza
pf = [] # punto di arrivo
percorsi = [] # tutti i percorsi possibili
minlen = 0 # lunghezza trovata

n = 10 # numero di colonne

m = 10 # numero di righe

x = 10 # numero di ostacoli

pi = [] # punto di partenza

pf = [] # punto di arrivo

percorsi = [] # tutti i percorsi possibili

minlen = 0 # lunghezza trovata

In particolare faccio notare che terremo tutti i percorsi in una lista percorsi = [] e vogliamo anche tenere traccia della minima lunghezza trovata con minlen. Questo accorgimento, come vedremo successivamente, ci servirà per ridurre notevolmente la quantità di calcoli da dover effettuare, eliminando tutti i percorsi che via via dovessero rivelarsi più lunghi del minimo percorso trovato (fino a quel momento).

A questo punto generiamo la matrice del mondo:

mtrx = [["-" for c in range(m)] for r in range(n)]

1	mtrx = [["-" for c in range(m)] for r in range(n)]

Adesso scriviamo la funzione per popolare il mondo di blocchi, le X del disegno precedente. Per farlo utilizzeremo la libreria random, per cui ricordiamoci di importarla all’inizio con import random

def blocchi():
    t = 0
    while t < x:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] != "X":
            mtrx[tr][tc] = "X"
            t += 1

def blocchi():

t = 0

while t < x:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] != "X":

mtrx[tr][tc] = "X"

t += 1

Utilizziamo random.randint per generare una posizione casuale su righe e colonne per i blocchi, verifichiamo che tale punto non sia già occupato da un blocco, in tal caso procediamo ad aggiungerlo.

In modo analogo creiamo un metodo che aggiunga la posizione iniziale A e quella finale B, registrandole nelle rispettive variabili.

def inizio():
    global pi, pf
    t = 0
    while t < 2:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] == "-":
            if t == 0:
                mtrx[tr][tc] = "A"
                pi = [tr,tc]
            else:
                mtrx[tr][tc] = "B"
                pf = [tr,tc]
            t += 1

def inizio():

global pi, pf

t = 0

while t < 2:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] == "-":

if t == 0:

mtrx[tr][tc] = "A"

pi = [tr,tc]

else:

mtrx[tr][tc] = "B"

pf = [tr,tc]

t += 1

Per trovare il percorso procediamo nella maniera seguente:

def trova(si,percorso=[]):
    # usiamo minlen come variabile globale
    global minlen
    # se la posizione corrente rientra nella matrice, allora procediamo
    if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:
        # se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo
        if mtrx[si[0]][si[1]] != "X" and si not in percorso:
            # aggiungiamo la posizione
            percorso.append(si)
            # se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione
            if len(percorso) > minlen and minlen > 0: return
            # se la posizione e' occupata dalla B allora abbiamo trovato la fine
            if mtrx[si[0]][si[1]] == "B":
                # se la lunghezza del percorso trovato e' minore della minore trovata
                # fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore
                if len(percorso) < minlen or minlen == 0: minlen = len(percorso)
                #aggiungiamo il percorso ai percorsi trovati
                percorsi.append([]+percorso)
            #altrimenti eseguiamo la funzione sulle caselle circostanti
            else:
                trova([si[0]-1,si[1]],[]+percorso)
                trova([si[0]+1,si[1]],[]+percorso)
                trova([si[0],si[1]-1],[]+percorso)
                trova([si[0],si[1]+1],[]+percorso)

def trova(si,percorso=[]):

# usiamo minlen come variabile globale

global minlen

# se la posizione corrente rientra nella matrice, allora procediamo

if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:

# se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo

if mtrx[si[0]][si[1]] != "X" and si not in percorso:

# aggiungiamo la posizione

percorso.append(si)

# se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione

if len(percorso) > minlen and minlen > 0: return

# se la posizione e' occupata dalla B allora abbiamo trovato la fine

if mtrx[si[0]][si[1]] == "B":

# se la lunghezza del percorso trovato e' minore della minore trovata

# fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore

if len(percorso) < minlen or minlen == 0: minlen = len(percorso)

#aggiungiamo il percorso ai percorsi trovati

percorsi.append([]+percorso)

#altrimenti eseguiamo la funzione sulle caselle circostanti

else:

trova([si[0]-1,si[1]],[]+percorso)

trova([si[0]+1,si[1]],[]+percorso)

trova([si[0],si[1]-1],[]+percorso)

trova([si[0],si[1]+1],[]+percorso)

Faccio notare una peculiarità, legata al modo in cui Python tratta le liste. Per passare il percorso attuale, copiandolo, alla funzione medesima, dobbiamo usare un piccolo trucco scrivendo []+percorso. In questo modo evitiamo che il percorso sia passato per riferimento, forzando il programma a crearne una copia.

Fatto tutto questo aggiungiamo un metodo per la stampa della matrice:

def stampa():
    for r in mtrx:
        for c in r:
            print(c,end="")
        print()

def stampa():

for r in mtrx:

for c in r:

print(c,end="")

print()

E un metodo per prendere uno dei percorsi più corti calcolati (ricordiamoci che potrebbero esserci più percorsi):

def elabora():
    for p in percorsi:
        if len(p) == minlen:
            for c in p:
                if c != pi and c != pf:
                   mtrx[c[0]][c[1]] = "o"
            print(p)
            break

def elabora():

for p in percorsi:

if len(p) == minlen:

for c in p:

if c != pi and c != pf:

mtrx[c[0]][c[1]] = "o"

print(p)

break

Infine uniamo tutto quanto insieme, importando anche la libreria temporale con import time per valutare la velocità di elaborazione.

ti = time.time()

blocchi()
inizio()

print("mappa senza percorso")
stampa()

trova(pi,[])

print("mappa con percorso")
elabora()
stampa()
print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

ti = time.time()

blocchi()

inizio()

print("mappa senza percorso")

stampa()

trova(pi,[])

print("mappa con percorso")

elabora()

stampa()

print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

Di seguito il codice completo:

import random
import time

n = 10 # numero di colonne
m = 10 # numero di righe
x = 10 # numero di ostacoli
pi = [] # punto di partenza
pf = [] # punto di arrivo
percorsi = [] # tutti i percorsi possibili
minlen = 0 # lunghezza trovata

mtrx = [["-" for c in range(m)] for r in range(n)]

def blocchi():
    t = 0
    while t < x:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] != "X":
            mtrx[tr][tc] = "X"
            t += 1

def inizio():
    global pi, pf
    t = 0
    while t < 2:
        tc = random.randint(0, m-1)
        tr = random.randint(0, n-1)
        if mtrx[tr][tc] == "-":
            if t == 0:
                mtrx[tr][tc] = "A"
                pi = [tr,tc]
            else:
                mtrx[tr][tc] = "B"
                pf = [tr,tc]
            t += 1

def stampa():
    for r in mtrx:
        for c in r:
            print(c,end="")
        print()

def trova(si,percorso=[]):
    # usiamo minlen come variabile globale
    global minlen
    # se la posizione corrente rientra nella matrice, allora procediamo
    if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:
        # se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo
        if mtrx[si[0]][si[1]] != "X" and si not in percorso:
            # aggiungiamo la posizione
            percorso.append(si)
            # se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione
            if len(percorso) > minlen and minlen > 0: return
            # se la posizione e' occupata dalla B allora abbiamo trovato la fine
            if mtrx[si[0]][si[1]] == "B":
                # se la lunghezza del percorso trovato e' minore della minore trovata
                # fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore
                if len(percorso) < minlen or minlen == 0: minlen = len(percorso)
                #aggiungiamo il percorso ai percorsi trovati
                percorsi.append([]+percorso)
            #altrimenti eseguiamo la funzione sulle caselle circostanti
            else:
                trova([si[0]-1,si[1]],[]+percorso)
                trova([si[0]+1,si[1]],[]+percorso)
                trova([si[0],si[1]-1],[]+percorso)
                trova([si[0],si[1]+1],[]+percorso)

def elabora():
    for p in percorsi:
        if len(p) == minlen:
            for c in p:
                if c != pi and c != pf:
                   mtrx[c[0]][c[1]] = "o"
            print(p)
            break
    
ti = time.time()

blocchi()
inizio()

print("mappa senza percorso")
stampa()

trova(pi,[])

print("mappa con percorso")
elabora()
stampa()
print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

import random

import time

n = 10 # numero di colonne

m = 10 # numero di righe

x = 10 # numero di ostacoli

pi = [] # punto di partenza

pf = [] # punto di arrivo

percorsi = [] # tutti i percorsi possibili

minlen = 0 # lunghezza trovata

mtrx = [["-" for c in range(m)] for r in range(n)]

def blocchi():

t = 0

while t < x:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] != "X":

mtrx[tr][tc] = "X"

t += 1

def inizio():

global pi, pf

t = 0

while t < 2:

tc = random.randint(0, m-1)

tr = random.randint(0, n-1)

if mtrx[tr][tc] == "-":

if t == 0:

mtrx[tr][tc] = "A"

pi = [tr,tc]

else:

mtrx[tr][tc] = "B"

pf = [tr,tc]

t += 1

def stampa():

for r in mtrx:

for c in r:

print(c,end="")

print()

def trova(si,percorso=[]):

# usiamo minlen come variabile globale

global minlen

# se la posizione corrente rientra nella matrice, allora procediamo

if si[0] >= 0 and si[0] < n and si[1] >= 0 and si[1] < m:

# se la posizione non e' occupata da un blocco e non e' gia' presente nel percorso procediamo

if mtrx[si[0]][si[1]] != "X" and si not in percorso:

# aggiungiamo la posizione

percorso.append(si)

# se il percorso supera la minima lunghezza trovata e tale lunghezza e' maggiore di 0, interrompiamo la ricorsione

if len(percorso) > minlen and minlen > 0: return

# se la posizione e' occupata dalla B allora abbiamo trovato la fine

if mtrx[si[0]][si[1]] == "B":

# se la lunghezza del percorso trovato e' minore della minore trovata

# fino a quel momento, oppure la minore lunghezza e' a 0, aggiorniamo la lunghezza minore

if len(percorso) < minlen or minlen == 0: minlen = len(percorso)

#aggiungiamo il percorso ai percorsi trovati

percorsi.append([]+percorso)

#altrimenti eseguiamo la funzione sulle caselle circostanti

else:

trova([si[0]-1,si[1]],[]+percorso)

trova([si[0]+1,si[1]],[]+percorso)

trova([si[0],si[1]-1],[]+percorso)

trova([si[0],si[1]+1],[]+percorso)

def elabora():

for p in percorsi:

if len(p) == minlen:

for c in p:

if c != pi and c != pf:

mtrx[c[0]][c[1]] = "o"

print(p)

break

ti = time.time()

blocchi()

inizio()

print("mappa senza percorso")

stampa()

trova(pi,[])

print("mappa con percorso")

elabora()

stampa()

print("percorsi trovati %d" % len(percorsi))

tf = time.time()

print("tempo di calcolo: %.2f s" % (tf - ti))

L’output finale darà qualcosa di simile a questo:

Vedi articolo