Relazione SudokuMatch - gianpaolo francesco trotta

SUDOKU
MATCH (beta)
Gianpaolo Francesco Trotta
Sommario
INTRODUZIONE.................................................................................................................................................. 3
OBIETTIVI ........................................................................................................................................................... 3
LINGUAGGI E AMBIENTI DI SVILUPPO USATI .................................................................................................... 4
TECNOLOGIA USATA .......................................................................................................................................... 5
CREAZIONE GRIGLIE SUDOKU: PSEUDO CODICE ............................................................................................... 6
Creazione della griglia soluzione ................................................................................................................... 6
Backtracking .................................................................................................................................................. 7
Creazione della griglia incompleta ................................................................................................................ 7
Verifica di univocità della soluzione .............................................................................................................. 8
Backtracking .................................................................................................................................................. 9
Calcola un’altra soluzione............................................................................................................................ 10
SITO WEB E PRESENTAZIONE DELL’APP .......................................................................................................... 10
OBIETTIVI FUTURI ............................................................................................................................................ 12
INTRODUZIONE
Il noto gioco Sudoku ha introdotto milioni di persone a problemi di soddisfacimento di
vincoli, anche se non se ne accorgono.
Una griglia di un Sudoku è formata da 81 caselle, alcune delle quali contengono cifre
da 1 a 9 altre, invece, sono vuote.
Il gioco consiste nel riempire tutte le caselle vuote in maniera tale che nessuna cifra
compaia due volte in una riga, colonna o riquadro 3x3. Una riga, colonna o riquadro si
chiama unità.
Una griglia di Sudoku è valida se ha esattamente un’unica soluzione.
OBIETTIVI
a) Implementazione di un algoritmo per la creazione di griglie Sudoku con
un’unica soluzione di livello facile (18 caselle vuote), medio (36 caselle vuote)
e difficile (54 caselle vuote).
b) Implementazione di un’app per dispositivi android che permetta all’utente di
risolvere griglie Sudoku precedentemente create e di poter competere con i
propri amici in una gara in cui vince chi è riuscito a completare prima la
griglia.
L’obiettivo a) è stato raggiunto.
L’obiettivo b) è stato raggiunto in parte. L’app creata permette solo la modalità “Single
Player”.
LINGUAGGIEAMBIENTIDISVILUPPO
USATI
Per il raggiungimento degli obiettivi lo studente ha impiegato:
a) Eclipse come ambiente di sviluppo per la creazione delle griglie Sudoku
b) il plugin ADT (Android Development Tools) per la creazione dell’app per
sistemi operativi Android.
c) l’editor di testo Gedit per la creazione di script che permettono
l’interfacciamento dell’app con un database MYSQL in cui sono salvate le
griglie e le relative soluzioni
I linguaggi di programmazione usati sono:
a) Java
b) PHP
c) Javascript
TECNOLOGIAUSATA
a) Raspberry Pi, un single-board computer con CPU ARM1176JZF-S 700MHz,
512 MB di RAM 16 GB di memoria che funge da server ospitante eseguibili
JAR per la creazione di griglie, un database per il salvataggio delle griglie e un
sito web che riguarda l’app. Il Raspberry Pi ha un sistema operativo Raspbian
(sistema operativo libero basato su Debian e ottimizzato per l’hardware del,
raspberry)
b) LG NEXUS 4, quarto smartphone di casa Google realizzato da LG e composto
da un processore Quad Core Snapdragon S4 Pro da 1.5 GHz, 2 GB di RAM e
16 GB di memoria con sistema operativo Android 4.4.2 KitKat Build KOT49H
usato come device per il test dell’app durante lo sviluppo
CREAZIONEGRIGLIESUDOKU:PSEUDO
CODICE
Creazione della griglia soluzione
alloca matrice grid 9x9
inizializza matrice grid
alloca matrice grid_domain 81x9
inizializza matrice grid_domain
inizializza un indice k a zero
while(indice i minore della larghezza di grid)
while(indice j minore della lunghezza di grid)
aggiorna dominio della variabile i,j in base ai valori trovati nella riga [1]
aggiorna dominio della variabile i,j in base ai valori trovati nella colonna [2]
aggiorna dominio della variabile i,j in base ai valori trovati nel riquadro 3x3 [3]
alloca domain
riempi domain [4]
if (la lunghezza di domain è 1)
assegna alla cella in posizione i,j il primo valore di domain
else if (la lunghezza di domain è maggiore di 1)
assegna alla cella in posizione i,j un valore in posizione random di domain
else
backtracking
incrementa k [5]
incrementa j
incrementa i
[1],[2],[3] l’aggiornamento del domino consiste nel mettere a -1 in grid_domain i valori
delle variabili che si trovano nella riga, colonna o riquadro 3x3 di grid relativi alla
posizione i,j
[4] domain è un vettore contenente solo i valori che è possibile inserire all’interno della
cella in posizione i,j
[5] k è l’indice di riga della grid_domain
Backtracking
ripristina il dominio della variabile in grid_domain alla riga k
decrementa l’indice k relativo a grid_domain
calcola la posizione i,j di grid in base all’indice k di grid_domain
assegna -1 il valore assegnato alla variabile in posizione i,j in grid, in grid_domain
assegna zero alla cella in posizione i,j in grid
decrementa k
calcola i,j
Creazione della griglia incompleta
Sono stati previsti 3 livelli di difficoltà:
1. Facile - 18 caselle vuote
2. Medio - 36 caselle vuote
3. Difficile - 54 caselle vuote
do
do
copia grid in sudokuZero
metti a zero in sudokuZero 18,36 o 54 caselle
calcola l’hash di sudokuZero
while ( hash di sudokuZero è presente nel database)
copia sudokuZero in newGrid
copia sudokuZero in newNewGrid
while( la soluzione non è unica ) [1]
inserisci nel database hash di sudokuZero, difficoltà, grid, sudokuZero [2]
[1] sudokuZero sarà la griglia incompleta con un’unica soluzione
[2] grid è la soluzione di sudokuZero (griglia incompleta)
Verifica di univocità della soluzione
alloca memoria per la matrice grid_domain 81x9 (contenente i domini delle singole celle)
inizializza grid_domain
inizializza l’indice k a zero
inizializza solution a zero
while (k è uguale a zero)
while (i è minore della lunghezza di newGrid)
while (j è minore della larghezza di newGrid)
aggiorna dominio della variabile i,j in base ai valori trovati nella riga [1]
aggiorna dominio della variabile i,j in base ai valori trovati nella colonna [2]
aggiorna dominio della variabile i,j in base ai valori trovati nel riquadro 3x3 [3]
alloca domain
riempi domain [4]
if (lunghezza di domain è maggiore o uguale a 1)
assegna a newGrid in posizione i,j il primo valore di domain
else
backtracking
incrementa k
incrementa solution
if (solution è uguale a 1)
if ( la soluzione trovata e salvata in newGrid è diversa da grid )
calcola altra soluzione
if ( l’altra soluzione è uguale a newGrid )
la soluzione è unica
else
la soluzione non è unica
else
la soluzione non è unica
else
la soluzione non è unica
[1],[2],[3] l’aggiornamento del domino consiste nel mettere a -1 in grid_domain i valori
delle variabili che si trovano nella riga, colonna o riquadro 3x3 di grid relativi alla
posizione i,j
[4] domain è un vettore contenente solo i valori che è possibile inserire all’interno della
cella in posizione i,j
[5] k è l’indice di riga della grid_domain
Backtracking
ripristina il dominio della variabile in grid_domain alla riga k
decrementa k
if ( k è minore di zero ) [5]
assegna 1 a k
assegna a i la lunghezza di newGrid
assegna a j la larghezza di newGrid
assegna -1 a solution
else
assegna valore -1 ad una variabile countK
while ( x è minore della lunghezza di sudokuZero )
while ( y è minore della larghezza di sudokuZero )
if ( sudokuZero in posizione x,y è uguale a zero )
incrementa countK
if ( countK è uguale a k )
assegna a i il valore di x
assegna a j il valore di y
assegna a x il valore della lunghezza di sudokuZero
assegna a y il valore della larghezza di sudokuZero
incrementa y
incrementa x
assegna -1 il valore assegnato alla variabile in posizione i,j in newGrid, in grid_domain
assegna zero alla cella in posizione i,j in newGrid
decrementa k
if ( k è minore di zero )
assegna a i il valore della lunghezza di newGrid
assegna a j il valore della larghezza di newGrid
else
assegna –1 a countK
while ( x è minore della lunghezza di sudokuZero )
while ( y è minore della larghezza di sudokuZero )
if ( sudokuZero in posizione x,y è uguale a zero )
incrementa countK
if ( countK è uguale a k )
assegna a i il valore di x
assegna a j il valore di y
assegna a x il valore della lunghezza di sudokuZero
assegna a y il valore della larghezza di sudokuZero
incrementa y
incrementa x
[5] Non esistono soluzioni
Calcola un’altra soluzione
A differenza del calcolo della prima soluzione (effettuato prima di creare la matrice
incomplete sudokuZero), considero una grid_domain inversa cioè con righe in cui i
valori dei domini vengono letti dal più grande al più piccolo e non dal più piccolo al più
grande come è stato fatto per la creazione della griglia soluzione.
In questa maniera possiamo affermare che la soluzione è unica nel caso in cui l’altra
soluzione è uguale alla griglia soluzione.
SITOWEBEPRESENTAZIONEDELL’APP
Il sito web è raggiungibile all’indirizzo http://gftrotta.no-ip.biz/sudokumatch
L’index contiene degli script PHP che leggono alcuni dati da file creati dagli eseguibili
JAR per ottenere informazioni circa la creazione delle griglie.
Ogni secondo, viene rilanciata l’index grazie ad una funzione jQuery che richiama uno
script AJAX per aggiornare i dati letti dai file.
L’app ha una grafica molto spartana, da migliorare in futuro, e si presenta in questa
maniera:
Cliccando su Easy, Medium o Difficult si richiamano rispettivamente easy.php,
medium.php e difficult.php.
Sono degli script in PHP che recuperano le matrici incomplete e le soluzioni di tutte le
griglie di livello facile, medio o difficile. Tra tutte le griglie, una a caso, viene stampata
come stringa JSON. Questa stringa viene letta da una funzione dell’app e si può
procedere alla creazione della griglia incompleta.
Maggiori sono le griglie, maggiore è il tempo di loading. In futuro si potrebbe
ottimizzare la funzione di recupero della griglia di gioco.
E’ possibile scaricare l’app collegandosi alla pagina web.
OBIETTIVIFUTURI
Ottimizzare gli algoritmi di creazione griglia e verifica di univocità della soluzione.
Trovare una soluzione al problema del tempo di loading della griglia sull’app.
Implementare la modalità “Player vs Player” usando, magari, l’email di un qualsiasi
social network a cui è iscritto l’utente per tenere traccia nel database dell’utente stesso.
Varie ed eventuali