Risolvere un cubo di Rubik blindfolded utilizzando i metodi M2/Old

I
Risolvere un cubo di Rubik blindfolded
utilizzando i metodi M2/Old Pochmann
scritto da
Giuseppe Sapia
version 2.11 – 25/03/2012
II
Premessa dell'autore
Questo tutorial non costituisce assolutamente farina del mio sacco!
Vuole semplicemente essere una revisione, solo parziale, degli scritti,
peraltro quasi integralmente riportati, di Federico Soldati (per le parti
riguardanti le risoluzioni degli spigoli tramite il metodo M2) e di Matteo
Colombo (per la parte riguardante la risoluzione degli angoli tramite il metodo
Old Pochmann), avente il fine d'illustrare in maniera, spero, un pochino più
chiara e fruibile, non tanto le tecniche di risoluzione suddette, quanto le
terminologie utilizzate: soprattutto per quanto riguarda M2.
Ho notato, infatti, che tanti (compreso il sottoscritto) hanno avuto difficoltà di
comprensione per quanto concerne M2, facendo spesso confusione col
significato dei termini “pezzo” o “sticker”, “buffer” o “pezzo del buffer” et alia,
arrivando taluni a desistere.
La mia speranza è che, leggendo questo scritto, almeno uno di questi taluni
possa tornare a insistere su M2.
La sezione riguardante la memorizzazione l'ho ridotta ai minimi termini,
fornendo dei cenni sulla tecnica alfanumerica; le lettere e i numeri riportati
nelle tabelle di setup e algoritmi degli spigoli e degli angoli, colonne “M”
(memorization), fanno appunto riferimento allo schema di pag. 2.
Pure gli esempi originali delle due guide citate sono ivi riportati.
*** *** *** *** *** ***
Una nota particolare di ringraziamento, poi, la destìno a Matteo (Colo)
Colombo e a Marco (Garsed) Mazzuoccolo per la disponibilità che hanno
prestato, prestano e presteranno a tutti coloro (sottoscritto compreso) che
amano il bld; nonché a Pisqua e ai nostri amici che, assemblati tutti in certa
orrida orchestra, con le vostre sinfonie notturne avete caratterizzato il primo
weekend dell'anno in quel de La Mazzanta, dirottando con forza e
ineluttabilità l'autore alla stesura finale del presente lavoro.
La Mazzanta, 22-05-2011
III
Indice
1) Nozioni di base
----------------------------------------------------------------------------------------------------------------------------------------------------------------
2) Memorizzazione
-----------------------------------------------------------------------------------------------------------------------------------------------------------
1
2
2a) Tecnica di memorizzazione alfanumerica----------------------------------------------------------------------2
3) Risoluzione degli spigoli: M2
-----------------------------------------------------------------------------------------------------------------
3
3a) Side edges---------------------------------------------------------------------------------------------------------------------------------------------------------------5
3b) Middle edges-------------------------------------------------------------------------------------------------------------------------------------------------------8
3c) Parity------------------------------------------------------------------------------------------------------------------------------------------------------------------------10
3d) Esempi--------------------------------------------------------------------------------------------------------------------------------------------------------------------1 1
4) Risoluzione degli angoli: Old Pochmann
-----------------------------------------------------------------------
13
4a) Esempio------------------------------------------------------------------------------------------------------------------------------------------------------------------16
5) Pezzi flippati
-------------------------------------------------------------------------------------------------------------------------------------------------------------------
17
5a) Spigoli-----------------------------------------------------------------------------------------------------------------------------------------------------------------------18
5b) Angoli------------------------------------------------------------------------------------------------------------------------------------------------------------------------19
IV
concept by Fabrizio Cirnigliaro & Albert Einstein
1
1) Nozioni di base
Per risolvere un cubo di Rubik a memoria bisogna, innanzitutto, memorizzare la
disposizione dei pezzi (spigoli e angoli) e, soprattutto, il loro orientamento, secondo
determinati criteri che fra poco vedremo; dopodiché si può cominciare a ricostruirlo.
Per fare ciò si utilizzano algoritmi che muovono esclusivamente pochi pezzi alla volta
affinché, durante la risoluzione, si sappia sempre in che stato si trova il cubo.
La prima nozione che bisogna imparare è il codice da utilizzare per identificare i diversi
stickers di un determinato pezzo, per cui è importante che sappiate a memoria, e senza
esitazioni, la disposizione dei colori sul vostro cubo (in questo tutorial userò la disposizione
europea: arancione opposto a rosso, giallo opposto a bianco, blu opposto a verde).
Dovrete, inoltre, decidere un orientamento standard in cui tenere il cubo durante la
risoluzione.
Io tengo Arancione in Up e Giallo in Front: quindi, a sinistra ci sarà il blu, a destra il
verde, dietro il bianco e sotto il rosso. Nel presente tutorial utilizzerò sempre, come
posizione di partenza, quest'orientamento!
Gli stickers dei pezzi vengono rappresentati (codice) da una determinata sequenza letterale:
due lettere per quelli degli spigoli, tre lettere per quelli degli angoli.
Per quanto concerne gli spigoli, la prima lettera della coppia rappresenta il lato su cui
giacerebbe, a cubo risolto, lo sticker (dello spigolo) preso in considerazione; la seconda
lettera corrisponde al secondo lato su cui giacerebbe, a cubo risolto, il secondo sticker (dello
stesso spigolo).
Ciò è più facilmente comprensibile con un esempio; tenete il cubo, risolto, nella posizione
standard che ho spiegato poco sopra: il codice RF rappresenta lo sticker verde dello
spigolo verde-giallo; R è il lato sui cui poggia lo sticker verde; F è il lato su cui poggia lo
sticker giallo.
Ecco altri esempi:
FR
BU
UB
DFR
FRD
RDF
rappresenta lo sticker giallo dello spigolo giallo-verde;
rappresenta lo sticker bianco dello spigolo arancione-bianco;
rappresenta lo sticker arancione dello spigolo arancione-bianco;
rappresenta lo sticker rosso dell’angolo DFR;
rappresenta lo sticker giallo dell’angolo DFR;
rappresenta lo sticker verde dell’angolo DFR;
Notate che per gli angoli vale la regola di scrivere il codice rispettando la disposizione in
senso orario dei due stickers seguenti il primo.
Ora che sono state chiarite le nozioni di base, siete pronti per entrare nella tecnica vera e
propria.
Dato che M2 e Old Pochmann sono due metodi indipendenti l’uno dall’altro (anche se
funzionano sullo stesso principio), comincerò a spiegare la risoluzione degli spigoli.
Ma, prima, parliamo un attimo delle tecniche di memorizzazione.
2
2) Memorizzazione
Esistono molte tecniche per memorizzare l’ordine dei pezzi del cubo di Rubik.
Molti usano lettere associate ad ogni sticker, altri usano metodi visuali.
Per avere un quadro più completo dei molti metodi utilizzabili, potete dare un’occhiata alla
sezione "Blindfold Cubing" del forum del sito: www.speedsolving.com.
2a) Tecnica di memorizzazione alfanumerica
Vi mostro solo un esempio dei tanti possibili: si assegnano ad ogni sticker, di ogni singola
faccia, delle lettere in ordine alfabetico, distribuendole in senso orario a cominciare dagli
stickers in alto a sinistra (per gli angoli) e in alto (per gli spigoli), iniziando dalla faccia Up;
proseguendo, poi, con F, R, B, L e infine Down: per quest'ultima si utilizzano dei numeri.
A / S / P
corner buffer
Q
q
R
p
Back
r
P
o
O
ULB position: buffer (corners)
V
v
S
A
a
B
L
l
M
3
3
4
u
Left
s
d
Up
b
i
Right
m
2
Down
4
U
t
T
D
c
C
I
n
N
2
-1-
-1-
E
e
F
h
Front
f
H
g
G
g / 1
edge buffer
FD position: buffer (edges)
Questa disposizione ha il pregio di fornire dei solidi punti di riferimento: in alto a sinistra
(per gli angoli) e in alto (per gli spigoli) delle prime 4 facce, infatti, si collocheranno
naturalmente tutte vocali (“A” per Up, “E” per Front, “I” per Right, “O” per Back); poi ci
saranno “S” per Left e “1” per Down.
3
3) Risoluzione degli spigoli: M2
M2, il metodo che utilizzeremo per risolvere gli spigoli, è stato inventato da Stefan
Pochmann nel 2006, il quale ne illustra il funzionamento base all'interno del suo sito
(www.stefan-pochmann.de).
Non fatevi spaventare dall'apparente complessità della tecnica, in quanto in buona parte è
intuitiva. Inoltre, la risoluzione di uno o più cubi di Rubik a memoria è così soddisfacente
da giustificare un piccolo sforzo!
Dobbiamo, innanzitutto, introdurre due concetti basilari;
Buffer (carica):
è la posizione ( FD ) dalla quale parte lo spigolo da spostare. Dunque, di quest'ultimo,
consideriamo lo sticker in FD e non quello in DF.
Target (obiettivo):
è la posizione ( BU ) d’arrivo dello spigolo che in precedenza stava in FD. Ovvero, lo
sticker in FD deve arrivare in BU (non in UB).
La formula che utilizzeremo per spostare lo sticker da FD a BU, come dice la tecnica, è M2.
In realtà, sono anche necessarie delle mosse di setup e antisetup da fare prima e dopo.
4
Ecco un semplice esempio per capire come ciò funziona; eseguite il seguente scramble:
M2 U R U' M2 U R' U'
In FD si trova lo sticker RF : ovvero, lo sticker verde è sul lato F (quello giallo sul lato D).
Per fare in modo che RF vada nel posto giusto, applicheremo questa semplice formula:
(U R U') M2 (U R' U')
(U R U')
Setup; colloca lo sticker che attualmente si trova in RF ( BU ), in BU: ovvero,
preleva lo spigolo che si trova nella posizione in cui dovrà essere collocato
lo spigolo trovantesi nel buffer, allocandolo nel target; e lasciando a posto
gli spigoli in FU, in BD e in FD (buffer).
Ergo, le mosse di setup consentite in M2 sono tutte, tranne: D, perché
inutile; e quelle che distruggono l'M layer, ad eccezione del target (BU),
visto che, ovviamente, bisogna portar lì i vari pezzi da scambiare con quelli
che si trovano nel buffer.
M2
Esegue lo scambio tra BU (target) ed FD (buffer): nel buffer, adesso, si trova
lo sticker BU che avevamo inizialmente spostato nel target con la setup.
Nel target, invece, si trova lo sticker RF .
(U R' U')
Antisetup; colloca RF (lo sticker da sistemare, trovantesi adesso nel target)
nella sua posizione naturale: RF, appunto.
Dato che abbiamo eseguito la mossa M2, i centri dell'M layer risulteranno ora invertiti.
Tutto questo tornerà, però, normale dopo aver fatto un altro scambio dello stesso tipo.
Per tale motivo, in questa versione di M2, durante la memorizzazione si ricorderanno
sempre due spostamenti alla volta.
Grazie a degli esempi che vi mostrerò dopo, tutto risulterà più chiaro.
5
3a) Side edges
È giunto il momento d'introdurre tutti i possibili spostamenti tra spigoli (ad eccezione di
quelli facenti parte dell'M layer, di cui ci occuperemo dopo):
In
Buffer
M
L
U
S
(L U' L' U) M2 (U' L U L')
(R' U R U') M2 (U R' U' R)
I
R
U
L
F
T
(U' L' U) M2 (U' L U)
(U R U') M2 (U R' U')
N
R
F
L
D
U
(U' L2 U) M2 (U' L2 U)
(U R2 U') M2 (U R2 U')
M
R
D
L
B
V
(U' L U) M2 (U' L' U)
(U R' U') M2 (U R U')
L
R
B
In
Buffer
M
M
In
Buffer
U
L
D
(B L' B') M2 (B L B')
(B' R B) M2 (B' R' B)
B
U
R
F
L
H
(B L2 B') M2 (B L2 B')
(B' R2 B) M2 (B' R2 B)
F
F
R
D
L
4
(B L B') M2 (B L' B')
(B' R' B) M2 (B' R B)
2
D
R
B
L
P
(L' B L B') M2 (B L' B' L)
(R B' R' B) M2 (B' R B R')
R
B
R
Sequences
Sequences
M
In
Buffer
Anche se questa lista vi sembra complicata, non spaventatevi: sono tutte formule molto
intuitive e quindi facili da apprendere.
Credo che il modo più semplice per capire il funzionamento di M2 sia un esempio.
Cercate di capire bene la logica di come si muovono gli spigoli: dovrebbe risultare,
appunto, molto intuitiva.
Fate questo scramble:
B2 R U D2 R2 L2 D L F2 U F2 L2 U' D L2 U' F2 B2 D2
Ora prendete carta e penna. Individuate, innanzitutto, lo sticker che si trova in FD
(non DF!): si tratta di RF ; quindi, sul vostro foglio scrivete “RF”.
- Dato che FD (posizione) è il buffer, questo non si memorizza mai
(come anche non si memorizzerà il pezzo -spigolo- buffer alla fine
del primo o unico ciclo: ovvero, gli stickers FD o DF
non si memorizzeranno mai!) -
6
Adesso, individuate lo sticker che si trova nel punto in cui arriva RF : in RF si trova LB ;
quindi, sul vostro foglio scrivete “LB”. Lo sticker che si trova in LB ( RD ) deve andare,
appunto, in RD; per cui scrivete “RD”.
Questo ciclo di spigoli terminerà quando v'imbatterete nello spigolo buffer, ovvero nella
posizione in cui si troverà uno sticker dello spigolo buffer.
A questo punto, dato che sarete passati da ogni spigolo non risolto, la sequenza terminerà.
Dovreste ottenere la seguente (ciclo unico):
FD
RF / LB ,
RD / LF , RU / RB
FD
Se, per ogni coppia di lettere, eseguite l’algoritmo corrispondente della lista, dovreste
ritrovarvi tra le mani, alla fine, il cubo risolto.
Per evitare equivoci, ecco le formule da eseguire in fila (prima eseguite RF/LB, poi RD/LF
etc, nello stesso ordine in cui è stata creata la sequenza):
RF / LB
(URU') M2 (UR'U') – (U'LU) M2 (U'L'U)
RD / LF
(UR2U') M2 (UR2U') – (U'L'U) M2 (U'LU)
RU / RB
(R'URU') M2 (UR'U'R) – (UR'U') M2 (URU')
Purtroppo, non è tutto così semplice come nell’esempio.
Spesso, durante la memorizzazione, capiterà di arrivare allo spigolo buffer senza essere
passati da tutti gli spigoli non risolti. In questo caso, bisognerà cominciare un nuovo ciclo
scegliendo lo sticker di uno spigolo da sistemare che richieda, preferibilmente, comode
mosse di setup per essere spostato nel target: si memorizzeranno dapprima la sua
posizione e poi lo sticker stesso.
Vediamo un esempio pratico; fate il seguente scramble:
U' F L2 U D' B2 L' D R U' D B' U D'
La sequenza comincia in questo modo:
FD
RB / LU , LB
A questo punto c’è un problema: in LB c’è uno sticker ( FD ) dello spigolo buffer; ma ci
rendiamo conto di non essere ancora passati da tutti gli spigoli non risolti.
Allora, procediamo così: scegliamo uno sticker di uno spigolo (non sistemato) allocato in
una posizione per la quale le mosse di setup e antisetup risultino semplici o addirittura nulle
(lo sticker allocato nel target -BU- richiede solo M2).
7
Nel caso di questo scramble (dato che BU si trova già in BU) scegliamo lo sticker che si
trova in RF (la cui sequenza è: URU' M2 UR'U').
La posizione (in questo caso RF) in cui si trova lo sticker dello spigolo scelto (in questo
caso, RD ) la scriveremo! E poi scriveremo lo sticker contenuto in quella posizione ( RD ,
appunto).
In questo modo, eseguendo prima la sequenza per “RF”, posizioneremo nel buffer lo sticker
iRD contenuto in questa posizione (RF, appunto), mentre lo spigolo buffer si collocherà
dal buffer alla posizione RF (in RD, ora, ci sarà UR ); dopodiché eseguiremo la sequenza
per “RD”, dato che nel buffer adesso si troverà RD .
Possiamo, dunque, continuare con la nostra sequenza (due cicli), che diventa:
FD
RB / LU , LB / FD
RF ,
RD / UR ,
FL / RF
----------------------------------------------------------------------- ------------------------------------------------------------------------
Dato che siamo tornati alla posizione (RF) in cui si trova lo sticker ( RD ) scelto per iniziare
il nuovo ciclo (oppure: dato che abbiamo incontrato uno sticker - RF - dello spigolo che
dovrà essere sistemato nella posizione che abbiamo scelto per iniziare il nuovo ciclo) e
poiché siamo passati da ogni spigolo non risolto, la nostra sequenza è terminata.
Lo sticker che troverà collocazione nella posizione scelta per iniziare il nuovo ciclo
-nell'esempio RF - si memorizzerà (a differenza degli stickers dello spigolo buffer);
e terminerà, così, il ciclo.
In alcuni casi capiterà di dover ricominciare più volte un nuovo ciclo (raramente più di
due). Il modo di procedere è sempre lo stesso: si sceglie lo sticker di uno spigolo da
sistemare, si memorizzano la posizione in cui si trova e poi lo sticker stesso; si continua la
sequenza fino a trovare uno sticker del pezzo che troverà collocazione nella posizione scelta
per iniziare il nuovo ciclo, e si annoterà.
--- --- --- --- --- --- --- --- ---
Una delle cose che non riuscivo a capire, quando ho cominciato a imparare M2/Old
Pochmann, era come fosse possibile rendersi conto, dovendo aprire un nuovo ciclo, degli
spigoli dai quali non ero ancora passato.
La risposta a questa domanda è: intuito.
Quando velocizzerete la vostra memorizzazione e dovrete cominciare nuovi cicli, vi
renderete conto intuitivamente da dove siete già passati e quando la sequenza sarà
terminata.
In caso di dubbio potete, comunque, sempre ripassare uno ad uno ogni spigolo e notare,
così, quali di essi restano ancora da risolvere.
8
3b) Middle edges
È giunto, ora, il momento d'imparare a inserire anche gli spigoli dello strato M.
Dato che la mossa M2 inverte costantemente i centri dello strato M e gli spigoli in esso
contenuti, durante la risoluzione potremo imbatterci in due possibili casi:
- centri dell'M layer posizionati correttamente (nella posizione in cui si trovavano
prima della risoluzione);
- centri dell'M layer invertiti (ruotati di 180º).
Per questo motivo, quando si risolveranno gli spigoli dell'M layer, dovrete tener conto dello
stato dello stesso, per evitare d'inserire gli spigoli nei punti sbagliati.
Con alcuni esempi, questo risulterà subito più chiaro. Ma vediamo, innanzitutto, gli
algoritmi (sequenze ottimizzate comprendenti M2) per gli spigoli centrali:
In
Buffer
M
F
D
(G)
D
F
(1)
B
D
Q
(M U2)*2
D
B
3
(M2 D) (R' U R' U') (M' U) (R U') M (R D')
F
U
E
(U2 M')*2
U
F
C
D (M' U) (R2 U') (M U) (R2 U' D') M2
B
U
O
M2
U
B
A
Algorithms (optimized sequences)
Notes
-------
Edge buffer
(U R' U') (B' R2 B) M2 (B' R2 B) (U R U') (*1)
-----
Edge target
Per quanto concerne l’inserimento degli spigoli centrali, vale questa regola:
Se, durante la memorizzazione del cubo (che procede a coppie), lo spigolo M è il primo
elemento della coppia, bisogna memorizzare la sequenza giusta. Se lo spigolo M è il secondo
elemento della coppia, bisogna memorizzare la sequenza opposta:
es. l’opposto di FU è BD e viceversa; l’opposto di DB è UF e viceversa.
Tale regola non vale per lo spigolo target, ovvero per gli stickers BU e UB .
Ciò potrebbe sembrare abbastanza confuso, ma in realtà è molto semplice: quando lo
spigolo M è il secondo elemento della coppia significa che, durante la risoluzione,
i centri M saranno invertiti.
(*1) In alternativa può essere usato quest'altro algoritmo, intuitivo: (U R' U') x' (R U' R U) M2 (U' R' U) x (R' U R U'). Si porta, dapprima, lo sticker trovantesi
n
nel target, in FR (UR'U'); poi lo si porta in BU (x'RU'RU); si esegue, quindi, M2 (che scambia gli stickers tra buffer e target); e poi si procede a ritroso.
9
Per questo motivo dovremo posizionare lo spigolo M, quando risulta come secondo
elemento della coppia, in maniera tale che poi, una volta ristabiliti correttamente i centri
dell'M layer con un numero pari di esecuzioni di M2, figuri nella sua allocazione naturale.
Questa caratteristica è l’ostacolo più grande nella comprensione di M2.
M
consider
them as
Algorithms
Notes
---
-------
Edge
buffer
F
D
(G)
D
F
(1)
B
D
E
F
U
(U2 M')*2
D
B
C
U
F
D (M' U) (R2 U') (M U) (R2 U' D') M2
F
U
Q
B
D
(M U2)*2
U
F
3
D
B
(M2 D) (R' U R' U') (M' U) (R U') M (R D')
B
U
O
B
U
M2
U
B
A
U
B
(U R' U') (B' R2 B) M2 (B' R2 B) (U R U')
inverse
2nd
elements
Regular
i
(Edge target)
Vediamo, ora, un esempio che include gli spigoli centrali; eseguite il seguente scramble:
R2 B2 D F2 R2 U R2 D2 B2 R2 D2 L D2 F' L B D' L' B' R'
Cominciamo a scrivere la nostra sequenza:
FD RB / UF (in realtà si tratta dello sticker DB , ma dato che è il secondo elemento
della coppia, memorizzo l’algoritmo dello sticker dello spigolo opposto; e continuo la
sequenza guardando qual è lo sticker che si trova in DB), UL / BL . Poiché in BL c’è uno
sticker dello spigolo buffer, per cominciare il nuovo ciclo scelgo lo sticker che si trova nel
target -BU- (che è DR ), dato che non ci sono ancora passato (basterà, poi, solo M2 per
portarlo nel buffer, senza mosse di setup e antisetup). La sequenza continua come segue:
DF BU / DR , RU / LF , DL / BD (anche in questo caso, dato che FU è il
secondo elemento della coppia, memorizzo l’algoritmo dello sticker dello spigolo opposto),
FR / UB ; dato che sono passato da ogni spigolo irrisolto, la mia sequenza (due cicli) è
terminata.
Onde evitare qualsiasi dubbio, ecco gli algoritmi da applicare in ordine:
RB / UF
(UR'U') M2 (URU') – D (M'U) (R2U') (MU) (R2U'D') M2
UL / BL
(BL'B') M2 (BLB') – (L'BLB') M2 (BL'B'L)
BU / DR
M2 – (B'R'B) M2 (B'RB)
RU / LF
(R'URU') M2 (UR'U'R) – (U'L'U) M2 (U'LU)
DL / BD
(BLB') M2 (BL'B') – (MU2)*2
FR / UB
(B'R2B) M2 (B'R2B) – (UR'U'B'R2B) M2 (B'R2BURU')
10
3c) Parity
Nel 50% delle risoluzioni, alla fine della sequenza rimarrà uno spigolo singolo che non
potrò memorizzare in coppia.
Questo, in termini di risoluzione, significa che avrò eseguito M2 un numero dispari di volte
e che, quindi, i centri del cubo dell'M layer saranno invertiti.
La formula (algoritmo di parità) che utilizzeremo per correggere la disparità, e quindi per
rimettere i centri a posto, è la seguente:
(U' F2 U) M2 (U' F2 U)
Dato che, per via di leggi matematiche che regolano lo spostamento dei pezzi del cubo di
Rubik, non si possono spostare due spigoli (o centri) soltanto, avremo forzatamente il
cosiddetto “side effect”, ovvero un effetto collaterale.
In questo caso, l’algoritmo per il ripristino della parità rimette a posto i centri (lasciando lo
spigolo in FD inalterato), ma allo stesso tempo inverte (permuta) gli spigoli in UB e UL:
caratteristica che, in questo caso, ci tornerà utile durante la risoluzione degli angoli, come
vedremo più in là.
Attenzione:
Se preferite ricomporre il cubo nell’ordine angoli-spigoli, dovete affrontare l'eventuale
caso di disparità in questo modo:
–
–
–
–
Risolvere tutti gli angoli tranne l'ultimo;
Risolvere tutti gli spigoli;
Eseguire l’algoritmo di parità;
Risolvere l'ultimo angolo.
--- --- --- --- --- --- --- --- ---
Durante la memorizzazione potreste notare degli spigoli e/o degli angoli flippati, cioè nel
posto giusto ma girati dalla parte sbagliata. Possono essere corretti, questi casi, con speciali
algoritmi, alla fine (dopo aver risolto sia gli spigoli, sia gli angoli) o durante la risoluzione;
comunque, vi spiegherò dopo come procedere per tali casi.
11
3d) Esempi
Prima di passare alla risoluzione degli angoli, penso sia una buona idea mostrarvi un paio di
risoluzioni complete di spigoli, corredate di tutte le formule da utilizzare, allo scopo di
chiarire qualsiasi dubbio ancora irrisolto.
Eseguite questo scramble:
F2 L2 U2 R2 F L B' F D B L2 R2 D' U L U2 B2 F
Partiamo, come al solito, dallo sticker in FD, che deve andare in LD; quello in LD va in
LU. A questo punto, ci troviamo davanti lo spigolo buffer: ricominciamo il nuovo ciclo
scegliendo lo sticker in BU, dato che è ancora irrisolto. Dopodiché, continuiamo la sequenza
finché non incontriamo uno sticker dello spigolo target, ovvero lo spigolo che dev'essere
allocato nella posizione scelta per iniziare il secondo ciclo (che incontreremo come secondo
elemento della coppia; ma poco importa, dato che lo spigolo target non è soggetto alla
regola menzionata precedentemente: memorizzeremo, dunque, la formula normale).
Ci rendiamo conto, però, che ci sono ancora alcuni spigoli non risolti che non abbiamo
memorizzato. Quindi, scegliamo adesso lo sticker in RB per iniziare il terzo ciclo (tale
posizione è arbitraria: potevamo anche scegliere lo sticker in BR o altre posizioni
contenenti altri spigoli irrisolti), continuando, così, la sequenza: in RB c'è lo sticker
iUFi (per cui memorizziamo la sequenza opposta, ovvero quella per “DB”, essendo UFi il
secondo elemento della coppia); in UF c'è lo sticker UR , in UR lo sticker BR .
Ci rendiamo conto di aver memorizzato tutti gli spigoli: la sequenza è terminata.
Ecco la sequenza completa (tre cicli) che dovremmo ottenere:
FD
LD / LU , FD
--------------------------------------------------------
BU / RF , LF / DR , DB / UB , RB / DB , UR / BR
------------------------------------------------------------------------------------
--------------------------------------------------------
Vediamo, ora, le formule da applicare:
LD / LU
(U'L2U) M2 (U'L2U) – (LU'L'U) M2 (U'LUL')
BU / RF
M2 – (URU') M2 (UR'U')
LF / DR
(U'L'U) M2 (U'LU) – (B'R'B) M2 (B'RB)
DB / UB
(M2 D) (R'UR'U') (M'U) (RU') M (RD')–(UR'U'B'R2B) M2 (B'R2BURU')
RB / DB
(UR'U') M2 (URU') – (M2 D) (R'UR'U') (M'U) (RU') M (RD')
UR / BR
(B'RB) M2 (B'R'B) – (RB'R'B) M2 (B'RBR')
12
Vediamo, adesso, un esempio più difficile.
Eseguite il seguente scramble:
L' R' B2 D2 U2 F2 R' D' U B' U2 F' D' B2 F2 D R U2
Dovreste essere in grado, ora, di ottenere da soli la sequenza corretta. Quando ho dovuto
cominciare un nuovo ciclo, ho scelto lo sticker allocato nella posizione RF ( FL ).
Ecco la sequenza (2 cicli) che dovreste ottenere:
FD
UR / DB , DB / LB , BR / UB , DF
-------------------------------------------------------------------------------------------------------------------
RF / FL , LD / LU , RB / FR
-----------------------------------------------------------------------------------
Ed ecco le formule da applicare:
UR / DBi
(B'RB) M2 (B'R'B) – (M2D) (R'UR'U') (M'U) (RU') M (RD')
DB / LBi
(M2D) (R'UR'U') (M'U) (RU') M (RD') – (U'LU) M2 (U'L'U)
BR / UBi
(RB'R'B) M2 (B'RBR') – (UR'U'B'R2B) M2 (B'R2BURU')
RF / FLi
(URU') M2 (UR'U') – (BL2B') M2 (BL2B')
LD / LU
(U'L2U) M2 (U'L2U) – (LU'L'U) M2 (U'LUL')
RB / FR
(UR'U') M2 (URU') – (B'R2B) M2 (B'R2B)
Facendo riferimento allo schema di pag. 2 (e alle colonne “M” relative alle tabelle degli
spigoli, pagg. 5 e 8-9), vediamo come diventa la sequenza ai fini della memorizzazione:
B / 3,
3 / Vi,
R / Ai, N / Hi, Ui / Si,
L / Fi
Questa può essere memorizzata, in maniera relativamente semplice, usando le stesse lettere
come iniziali delle parole sequenziali di una frase che costruiremo ad hoc (che, per ovvie
ragioni, potrà avere più o meno senso compiuto e trattare, altresì, argomenti o eventi che
possano far particolare presa nella nostra memoria, compresi quelli di natura più scabrosa).
Una tra le tante potrebbe essere:
“Babbo 33 Volte Ruppe Amicizie; Non Ha Un Solo Legame Forte”
13
4) Risoluzione degli angoli: Old Pochmann
E' giunto il momento d'imparare la tecnica per gli angoli.
Se avete chiaro il funzionamento di M2, Old Pochmann richiederà pochissimo sforzo,
in quanto funziona in maniera similare:
Setup – Y perm – Antisetup
Come in M2, anche in Old Pochmann lavoreremo con due posizioni chiave;
Buffer (carica):
è la posizione ( ULB ) dalla quale parte l'angolo da spostare. Dunque, di quest'ultimo,
consideriamo lo sticker in ULB e non gli altri due (quelli in LBU e in BUL).
Target (obiettivo):
è la posizione ( URF ) d’arrivo dell'angolo che in precedenza stava in ULB. Ovvero, lo
sticker in ULB deve arrivare in URF (non in RFU e neanche in FUR).
Il PLL che utilizzeremo, dopo la setup e prima dell'antisetup, dunque, è la Y perm:
(F R U’) (R’ U’ R U) (R’ F’) (R U R’ U’) (R’ F R F’)
Potete comunque usare il vostro algoritmo, purché vengano permutati sempre i due spigoli
contenuti nelle posizioni (UB e UL) adiacenti al buffer (ULB).
Le mosse di setup consentite sono: F, f; R, r; D, d; e naturalmente anche le rotazioni in
senso antiorario e quelle di 180º. Le restanti mosse (B, b; L, l; U, u) sono vietate in quanto
cambierebbero irrimediabilmente i 2 spigoli contenuti nelle posizioni UB e UL.
Se qualcuno volesse impararle a memoria, ecco le tabelle relative:
14
- Up corners -
Sequences
M
In Buffer
(R D’ F’) Yp (F D R')
B
U B R
R' Yp R
O
B R U
(R D’ R) Yp (R’ D R’)
L
R U B
M
In Buffer
Yp
C
U R F
(F’ D F’) Yp (F D' F)
(R' F') Yp (F R)
I
R F U
F Yp F'
(F R) Yp (R' F')
F
F U R
M
In Buffer
In Buffer
M
U L B
(A)
L B U
(S)
B U L
(P)
In Buffer
M
U F L
D
(F’ D R) Yp (R' D' F)
F L U
E
L U F
T
Corner buffer
Sequences
- Down corners -
Sequences
In Buffer
M
D L B
4
(D' R2) Yp (R2 D)
R2 Yp R2
3
D B R
L B D
V
(D2 F') Yp (F D2)
(D’ F') Yp (F D)
R
B R D
B D L
Q
(D2 R) Yp (R' D2)
(D' R) Yp (R' D)
M
R D B
In Buffer
M
M
In Buffer
D L F
1
F2 Yp F2
(D R2) Yp (R2 D')
2
D F R
L F D
U
(D R) Yp (R' D')
R Yp R'
G
F R D
F D L
H
(D F') Yp (F D')
F' Yp F
N
R D F
Sequences
15
Come probabilmente avrete già notato, le mosse di setup e le relative inverse sono
estremamente semplici e intuitive.
Il funzionamento di Old Pochmann rispecchia completamente la logica di M2: si parte dallo
sticker allocato nel buffer (ULB), si guarda dove deve andare... e così via.
Anche in questo caso, come per gli spigoli, ci sarà un'interruzione di ciclo quando l'angolo
buffer ritornerà nel punto di carica. In tali casi, se vi saranno ancora degli angoli da
sistemare, bisognerà cominciare un nuovo ciclo scegliendo uno sticker di un angolo da
sistemare allocato, preferibilmente, in un punto che richieda comode mosse di setup (o
addirittura nessuna, se sceglieremo quello già posizionato nel target: URF, per la cui
risoluzione basterà eseguire la sola Y perm), come ad esempio quello in FRD (R) o quello
in BRU (R') .
Si memorizzeranno dapprima la sua posizione e poi lo sticker stesso.
Dato che non si possono spostare (permutare) due angoli soltanto, eseguendo la Y perm
instauriamo il cosiddetto “side effect”, che in questo caso consiste nella permutazione
degli spigoli allocati nelle posizioni UB e UL.
Ciò significa che, se al termine della risoluzione degli angoli avremo applicato la Y perm un
numero pari di volte, il nostro cubo sarà risolto, dato che gli spigoli in UB e UL saranno
ritornati nella posizione originaria.
Se, invece, alla fine della risoluzione degli angoli avremo eseguito la Y perm un numero
dispari di volte, gli spigoli in UB e UL risulteranno invertiti.
L’eventualità di un numero dispari di applicazioni della Y perm verrà risolta con la parità
degli spigoli: se, durante la memorizzazione degli spigoli, resteremo con uno spigolo
singolo che non potrà essere memorizzato in coppia, ciò significherà che avremo,
forzatamente, anche un numero dispari di angoli da sistemare.
Ricordate, quindi, questa regola:
numero (pari o dispari) di spigoli da sistemare = numero (pari o dispari) di angoli dai
isistemare
Questo spiega l’applicazione dell’algoritmo di parità dopo la risoluzione di un numero
dispari di spigoli: esso mette a posto i centri e permuta gli spigoli contenuti nelle posizioni
UB e UL.
In questo modo, applicando in seguito un numero dispari di volte la Y perm, che permuterà
anch’essa gli spigoli contenuti nelle posizioni UB e UL, otterremo un cubo risolto.
16
4a) Esempio
Vediamo un esempio di una risoluzione solo angoli; fate il seguente scramble:
B2 R2 D2 L’ R F L R B’ U F L2 F2 L’ F U’ B’.
Il meccanismo è lo stesso di quello illustrato per gli spigoli; provate a scrivere da soli la
sequenza; dovreste ottenere la seguente:
ULB
DFR / FLU , RDB / UBR , DLFi / ULB
Per cambiare ciclo ho usato lo sticker più semplice: quello contenuto nel target (URF).
Ricordate che, se per caso, URF fosse già occupato da URFi o non voleste comunque, per
qualsiasi ragione, sistemare il pezzo ivi residente, siete liberissimi di portare nel target un
altro sticker di un pezzo (angolo) irrisolto allocato in una posizione diversa.
Se avete fatto tutto giusto, la completa sequenza (due cicli) dovrebbe essere:
ULB
DFR / FLU , RDB / UBR , DLFi / ULB
URF ,
BDL / URFi
---------------------------------------------------------------------------------------------------------------------------------- -----------------------------------------------------
Per non sbagliare, ecco le formule da applicare in ordine:
DFR / FLU
(DR2) Yp (R2D’) – (F’DF’) Yp (FD’F)
RDB / UBR
(D’R) Yp (R’D) – (RD’F’) Yp (FDR’)
DLFi / URF
F2 Yp F2 – Yp
BDL / URF
(D2R) Yp (R'D2) – Yp
Facendo riferimento allo schema di pag. 2 (e alle colonne “M” delle tabelle degli angoli,
pag. 14), vediamo come diventa la sequenza ai fini della memorizzazione:
2 / E,
M / B, 1 /C,
Q / C
Come nell'esempio precedentemente fatto per gli spigoli, proviamo a costruire, con queste
lettere, una frase ad hoc; una delle tante potrebbe essere:
“2 Embarghi Molto Biechi, 1 Come Quello Cubano”
17
5) Pezzi flippati
Dovete imparare, adesso, a girare eventuali angoli e spigoli che si trovano nella posizione
giusta, ma orientati nel modo sbagliato.
Come già detto in precedenza, essendo i pezzi flippati indipendenti dal resto della
risoluzione (per ovvie ragioni, non li troveremo mai all'interno di un ciclo), possono essere
risolti in qualunque momento.
Usando degli algoritmi (che coinvolgono due o più pezzi alla volta) appositi, le mosse di
setup saranno libere: non ci sarà nessun vincolo; ovviamente, se per “setuppare”,
spostandolo, un pezzo da flippare (spigolo o angolo) spostassi pure un altro che devo
flippare, questo non avrà senso.
18
5a) Spigoli
Per flippare gli spigoli, questi sono gli algoritmi, tra i tanti possibili, più utilizzati:
Orient edges
Effect
Flips
Algorithms
UB / UL / FD / BD
(M' U)*4
UF / UB
(M' U)*3 U (M U)*3 U or (M U)*3 U (M’ U)*3 U
UB / UL / UF / UR
(M' U M' U M' U M' U')*2
UF / UR
(R' U2) (R2 U R' U') (R' U2) (L F R F' L')
Se conoscete questa lista di formule (dalle quali se ne possono ricavare altre), potete
risolvere gli spigoli al massimo con due mosse di setup.
In realtà, basterebbe la formula per UF/UB:
(M' U M' U M' U2 M U M U M U2)
Così si rischia, però, di dover fare i salti mortali con le mosse di setup e antisetup: soluzione
che, spesso, genera confusione; anche se riuscire a padroneggiarle con sicurezza costituisce
un fortissimo vantaggio.
Dato che non è possibile che ci sia un numero dispari di spigoli flippati, valgono queste
regole:
- se, durante la memorizzazione, riscontriamo un solo spigolo flippato, alla fine della
iiirisoluzione dei pezzi lo sarà (flippato) anche lo spigolo buffer;
- se vi sono due spigoli flippati, lo spigolo buffer sarà corretto;
- se vi sono tre spigoli flippati (molto raro), lo sarà anche lo spigolo buffer.
19
5b) Angoli
Per risolvere un angolo flippato, basta memorizzare la posizione di uno dei 3 stickers del
suddetto (generalmente quello più comodo da spostare nel target), memorizzando poi dove
dev'essere allocato; ad esempio, se nella posizione FRD troviamo lo sticker DFR (angolo
ruotato in senso orario), per flippare correttamente l'angolo in questione basterà
memorizzarne dapprima la posizione corrente di uno sticker a piacere (in questo caso può
essere comodo scegliere lo sticker rosso nella posizione FRD, dato che per portarlo nel
target basterà eseguire R) e poi la posizione ove esso dovrà essere collocato (se scegliamo lo
sticker rosso, sarà DFR).
Dunque, in questo caso, una delle sequenze possibili da memorizzare per flippare
correttamente il suddetto angolo, sarà: FRD / DFR (se scegliamo lo sticker rosso,
appunto), ovvero: G / 2 .
Risolvendo gli angoli flippati in questo modo, non dovremo assolutamente preoccuparci
dell'angolo buffer: si autoflipperà in maniera corretta da solo; e le mosse di setup consentite
rimarranno: F, f; R, r; D, d (più le rotazioni in senso antiorario e quelle di 180º).
Per flippare gli angoli, possono pure essere usati i seguenti algoritmi:
Effect
Spin
Clockwise
Counterclockwise
Counterclockwise
Orient corners
Clockwise
Clockwise
Counterclockwise
Counterclockwise
Clockwise
Clockwise
Counterclockwise
Counterclockwise
Clockwise
Algorithms
URF
ULB
z (R' U R2 U') (R2 U' R' U) (R U R' U') (R2 U' R2 U) z'
URF
ULB
z (R U R2' U') (R2 U' R' U) (R U R' U') (R2 U' R2 U) R2 z'
UFL
ULB
(R U R' U')*2 L' (U R U' R')*2 L
UFL
ULB
(U R U' R')*2 L' (R U R' U')*2 L (*2)
DFR
ULB
U2 (R U2) (R U R' U) (R U2' R' U') U' (R' U' R U' R')
DFR
ULB
(R U R' U) (R U2) (R U2' R' U') (R U' R' U2) (R' U2)
(*2) Double Niklas – In alternativa possono essere usate, in sequenza, prima la Sune (R U R' U R U2 R') e poi l'anti-Sune (L' U' L U' L' U2 L), o viceversa.
20
Se imparate questa lista di formule, potete risolvere gli angoli flippati con pochissime mosse
di setup (altrimenti basta conoscerne una soltanto delle prime quattro, con lo scotto di dover
eseguire poi qualche mossa di setup e antisetup in più).
Dal punto di vista della matematica del cubo di Rubik, un discorso similare a quello fatto
per gli spigoli, ma un po' più complicato, vale per gli angoli, in quanto possono essere
flippati sia in senso orario che in senso antiorario.
Dato che ci possono essere solo due angoli flippati in senso opposto o tre angoli flippati
nello stesso senso, valgono queste regole:
- se, durante la memorizzazione, riscontriamo un solo angolo flippato, alla fine della
sarisoluzione lo sarà anche l'angolo buffer, ma in senso opposto (se il primo è flippato in
sesenso orario, il secondo lo sarà in senso antiorario o viceversa);
- se ci sono solo due angoli flippati in senso opposto, l'angolo buffer sarà corretto;
- se vi sono due angoli flippati nello stesso senso, l'angolo buffer sarà flippato nello stesso
sesenso;
- se vi sono tre angoli flippati nello stesso senso, l'angolo buffer sarà corretto;
mma se uno di questi tre angoli è flippato in senso inverso, lo sarà anche l'angolo buffer.
Giuseppe Sapia