Indice Rubik
Home: Http://digilander.iol.it/tamanti
Istruzioni d'uso del programma prolog.
Rubik in prolog (zippato)
Per eseguire il programma è necessario possedere un interprete di linguaggio prolog.
Alcuni di questi:
Poi, una volta installato l'interprete, bisogna interpretare il codice
Rubik.pl zippato, oppure
Rubik.txt (il primo deve essere decompresso,
mentre al secondo bisogna modificare l'estensione in .pl).
Una volta avviato l'interprete, scrivere
"consult('Rubik').",
oppure precedere a Rubik il percorso assoluto o relativo alla directory "bin"
dell'interprete. Ad esempio
"consult('../Codice/Rubik').".
Importante è non dimenticarsi mai il punto finale!
Se tutto va bene dovrebbe comparire l'intestazione del programma che ci indica anche
i comandi per ottenere l'help:
se si utilizza Sicstus prolog "help."; invece
se si utilizza SWI-Prolog "user_help.", visto che
"help." è utilizzato dall'interprete per far partire la sua shell di help.
All'inizio il cubo è già disordinato; per far partire il risolutore è sufficiente dare il
comando "go."
Ops... forse capirete poco di ciò che vi si presenterà sul video.
Provate a dare il comando "cubo." che riporta il
cubo nella posizione base, con le facce ognuna del proprio colore. Poi con il
comando "l." stampiamo la situazione attuale:
[[bvr,x],[brg,x],[bga,x],[bav,x],[cva,x],[cag,x],[cgr,x],[crv,x]]
[[bv,x],[br,x],[bg,x],[ba,x],[vr,y],[gr,y],[ga,y],[va,y],[ca,x],[cg,x],[cr,x],[cv,x]]
Questa è la posizione base del cubo, con le facce ognuna del proprio colore. Le lettere
indicano ognuna uno dei sei colori:
b=bianco, v=verde, r=rosso, a=arancio, g=giallo, c=cobalto (blu).
Ho considerato il cubo come essere formato da 27 cubetti (3*3*3), di cui 7 sono fissi:
- Uno è al centro ed è nascosto.
- 6 sono lungo gli assi centrali e ruotano solamente: sono al centro di ogni faccia.
- 12 vertici, ognuno di 3 colori diversi (3 faccette colorate).
- 8 spigoli, ognuno di 2 colori diversi (2 faccette colorate).
Dunque per descrivere il cubo basta prendere in considerazione gli ultimi 20 cubetti.
Per identificarli ho utilizzato i colori delle faccette: "bvr" è il vertice con una faccetta
bianca, una verde ed una rossa, mentre "bv" è lo spigolo con una faccetta bianca ed una
verde.
Ogni cubetto può inoltre essere orientato in modo diverso: ad esempio "bvr" può avere la
faccetta bianca in direzione dell'asse x, y oppure z. Questo stanno ad indicare le lettere
x,y,z: l'asse x è quello che va dalla faccia bianca a quella cobalto (blu), l'asse y da
quella verde a quella gialla e z da quella rossa a quella arancio.
Come punto di riferimento di ogni cubetto ho considerato il colore della prima faccetta
(in ordine prima il binco o il cobalto, poi il verde o il giallo).
Per ruotare di 90 gradi in senso orario la faccia bianca il comando è
"b.", oppure "b1.",
Per ruotarla di 180 gradi "b2.".
Per ruotarla in senso antiorario "b3.".
Nello stesso modo si costruiscono le mosse per ruotare le altre facce: basta sostituire
la b (sta per bianco) con la lettera corrispondente al colore relativo:
b=bianco, v=verde, r=rosso, a=arancio, g=giallo, c=cobalto (blu).
(Dunque "v.", "v2.",
"v3.", "r.",
"r2.", ...).
Durante la ricerca della soluzione applico delle sequenze di mosse singole:
"bv8." che equivale a
"b,v,b,v3,b,v,b2,v3.":
alla fine sono spostati 4 vertici e 2 spigoli;
"bvr4x4." che equivale a
"b3,v,b,v3,b3,v,b,v3,r,v3,r3,v,r,v3,r3,v.":
cambia orientamento a 2 spigoli (bv,br) ed a 2 vertici;
"bv12." che equivale a
"b,v3,b3,v,b,v3,b3,v,b,v3,b3,v.":
sposta 4 vertici a coppie di 2;
"bv16." che equivale a
"b,v2,b3,v,b3,v2,b,v2,b,v,b3,v3,b3,v,b,v2.":
cambia orientamento a 2 vertici;
In modo analogo si costruiscono le sequenze relative ad altre facce, es:
"rc8." che equivale a
"r,c,r,c3,r,c,r2,c3.":
All'avvio del programma il cubo è in posizione casuale. Per controllare la posizione
attuale dei cubetti uso il comando "diversi."
che stamperà una cosa simile a
[[[cva,y],[bvr,x]],[[cag,z],[brg,x]],[[cgr,y],[bga,x]],[[brg,y],[bav,x]],[[bvr,y],[cva,x]],[[bav,x],[cag,x]],[[bga,y],[cgr,x]],[[crv,y],[crv,x]]]
[[[br,x],[bv,x]],[[gr,x],[br,x]],[[bv,y],[bg,x]],[[cr,x],[ba,x]],[[cv,y],[vr,y]],[[bg,y],[gr,y]],[[vr,z],[ga,y]],[[va,z],[va,y]],[[ga,x],[ca,x]],[[ba,y],[cg,x]],[[cg,x],[cr,x]],[[ca,x],[cv,x]]]
che indica che il vertice "cva" è orientato in direzione y e che attualmente occupa la
posizione del vertice "bvr", che "cag" occupa la posizione di "brg", ecc...
Per avviare la ricerca della soluzione: "go."; appariranno
vari messaggi per qualche secondo, poi "Finalmente".
L'algoritmo sistema prima tutti gli spigoli (quelli con 2 solo faccette), posizionandoli
ed orientandoli, poi tutti i vertici (quelli con 3 faccette) posizionandoli e orientandoli.
"Profondità: #" indica quanto l'algoritmo sta indagando in profondità nell'albero
delle possibili mosse.
"2 spigoli fuori posto, cioè:[[[cv,z],[cr,x]],[[cr,x],[cv,x]]];" indica che lo
spigolo "cv" è orientato in direzione 'z' e che attualmente occupa la posizione dello
spigolo "cr".
Una cosa importante da sottolineare è il fatto che il comando "go."
ci dice solo le mosse che dovremmo fare per risolvere il cubo, ma lascia inalterate le
posizioni, così ripetendo due volte consecutive il comando "go."
ci viene presentato lo stesso output.
Per avere il cubo nella posizione base "cubo." e se poi
facciamo "diversi." ci verrà indicato [][], cioè tutti i
vertici e gli spigoli sono a posto.
Per inserire una precisa configurazione del cubo:
"leggiv(V)." e "leggis(S).",
dove al posto di "V" bisognerà inserire una lista tipo [[bav,y],[bvr,z],[cag,x],[bga,z],[crv,x],[cgr,y],[brg,x],[cva,z]]
ed al posto di "S" [[va,x],[gr,x],[bg,y],[br,x],[ba,y],[bv,z],[ga,z],[ca,y],[cv,x],[cg,y],[vr,x],[cr,x]].
Il programma non controlla i dati inseriti, perciò controllate se si stanno inserendo
tutti i pezzi una unica volta. Inoltre fate attenzione a non mettere a caso i vertici e gli
spigoli, altrimenti si potrebbe inserire una configurazione impossibile, cioé una
configurazione raggiungibile solo "smontando" il cubo. Questo avviene a causa di proprietà
geometriche: non è per esempio possibile con nessuna sequenza di mosse, grande a piacere,
spostare o ruotare un unico vertice, né un unico spigolo (anzi gli spigoli vanno a gruppi di
3). Si può cambiare l'orientamento di 2 soli vertici, ma lasciandoli nelle loro posizioni...
Per inserire una configurazione lecita suggerisco di copiarla da un cubo di Rubik reale.
Per disordinare in modo automatico il cubo: "disordina."
(oppure "d.") esegue 10 mosse random.
"disordina(N).": esegue N mosse random.
Esiste poi anche il comando "help_more." per visualizzare
alcuni ulteriori comandi:
"vertici_ok(V), spigoli_ok(S)."
per visualizzare le posizioni base;
"vertici_ko(V), spigoli_ko(S)."
per visualizzare le posizioni attuali.
Infine il comando "help_all." visualizza tutti i
predicati usati nel programma: mosse/7 indica una funzione denominata mosse con 7
parametri.
Home