Un venerato tempo di passaggio dei pedanti è quello di sottolineare che le immagini dei "cubi di Rubik" (su magliette, poster ecc.) Non sono in realtà risolvibili.

La prima cosa da controllare è che il cubo sia composto dai pezzi giusti. Per essere risolvibile, un cubo necessita di sei colori ciascuno con nove quadrati. Il cubo ha anche bisogno di ogni unità di bordo e angolo (questi sono i cubi più piccoli che compongono il cubo) per essere unici. Non solo devono essere unici, ma se due pezzi centrali sono uno di fronte all'altro, nessun bordo o pezzo d'angolo può contenere entrambi quei colori.

Una volta che hai un cubo composto da tutti i pezzi giusti, devi ancora verificare che sia risolvibile. Ci sono un paio di regole qui, quindi rimanderò a un esperto per spiegarle, lo spoiler qui sotto spiega come possiamo farlo. Se sei interessato a risolvere il problema da solo, non è necessario visitare il sito per comprendere o partecipare a questa sfida.

Spiegazione collegata

Il tuo compito è quello di prendere uno schema come input e determinare se si tratta effettivamente di un cubo di Rubik risolvibile. Per essere risolvibile, ci deve essere un modo per eseguire mosse valide su un cubo in modo che il cubo abbia un solo colore su ogni faccia (e le diverse facce abbiano colori diversi). La maggior parte dei cubi di Rubik ha una colorazione standard (il bianco è opposto al giallo, ecc.) Non si può presumere che lo stato di risoluzione segua questa particolare colorazione.

Una mossa valida è la rotazione in senso orario o antiorario di una singola faccia del cubo. Con la rotazione della faccia del cubo vengono ruotati anche i quadrati che delimitano la faccia, rimanendo collegati alla faccia che precedentemente toccavano.

IO

Puoi prendere il cubo in qualsiasi modo ragionevole. Se la tua lingua ha un tipo "cube-face" incorporato, buono per te, che va bene come input, in altre parole puoi prendere un array 2D della rete, del cubo, 1 3 per 3 elenchi per ogni faccia. Sii ragionevole. Se vuoi sapere se un formato specifico è un commento accettabile o esegui il ping in chat e aggiungerò la sfida per dichiararne la validità.

Il formato di input deve supportare solo fino a 9 colori possibili.

Per l'output questo è un problema decisionale, quindi dovresti generare un valore costante per "Sì, questo è un cubo di Rubik valido" e un diverso valore costante per "No, questo non è un cubo di Rubiks valido".

Questo è code-golf, quindi le risposte verranno classificate in byte con meno byte migliori.

Casi test

Ecco i casi di test. Sono formattati come la rete di un cubo con ogni quadrato come una singola lettera. Lettere diverse rappresentano colori diversi. Eventuali ulteriori test possono essere aggiunti su richiesta.

Risolvibile

   RRR
   RRR
   RRR
GGGWWWBBBOOO
GGGWWWBBBOOO
GGGWWWBBBOOO
   YYY
   YYY
   YYY


   GRR
   GRR
   ORW
WWRBWYBOOGGY
GGRBWGYBBOOO
OOGRWGYWWRBB
   WYO
   YYB
   YYB

irrisolvibile

   RRR
   RRR
   RRR
GGGWWWBBBOOO
GGGWWWBBBOOO
GGGWYWBBBOOO
   YWY
   YYY
   YYY


   RRR
   RRR
   RRR
GGGWWWBBBOOO
GGGWWWBBBOOO
GGGWWWBBBOOO
   YWY
   YYY
   YYY


   RRR
   RRR
   GGG
GGYWYWRBBOBO
GGYWWWROBOOO
GGYWWWRBBOOO
   BBB
   YWY
   YYY


   RRW
   RRW
   GGG
GGYWWYEOBROO
GGYWWYEBBROO
GGOWWYWBBROO
   BBB
   YYW
   YYO

Cubicamente , 1664 1631 1089 byte

⇒FD2F'R'D2RUR'D2RFD2F'U'
⇒Ff1F'
⇒LFf1F'L'
⇒F'f1F
⇒F2f1F2
⇒L'F2f1F2L
⇒D'F'f1FD
⇒LR'FLR'DLR'B2L'RDL'RFL'RU2
⇒LFf8F'L'
⇒R'F'f8FR
⇒Ff8F'
⇒F'f8F
⇒ULU'f8UL'U'
⇒U'R'Uf8U'RU
⇒F2f8F2
⇒Df15D'
⇒D'f15D
⇒D2f15D2
⇒UF2UF2D'L2B2U'B2DL2F2D2B2D2F2
⇒U'DL2UD'B2
⇒UF2UF2D'L2B2D'R2UR2F2D2B2U2B2
⇒BL'BU2D2F'RF'U2D2
⇒LD'F2U'B2U'RU2R'F2R2F2D'R2DF2D
⇒B2URB2D2B2RB2U'D'L2D'B2
⇒B2LF'U'B2UFL'R2B2U'D2L2D'B2U
⇒B2RB2D2B2RB2U'L2UD'F2U'F2B2
⇒D2R'FUB2U'F'RU2B2D'F2R2UF2UF2
⇒B2R2U'L'D2B2U2R'U2R2F2L2R2UR2
⇒D2L'B2U2F2RUL2U'F2R2U'R2U2F2DL2D'
⇒UB2U'L2DL2B2DB2D'B2
⇒BR'BL2B'RBL2B2
⇒UF2B2U'F2B2U'F2L2R2B2R2
⇒R2U'F2DR2UF2D'R2DF2R2D'F2
⇒U'F2DF2UL2F2DL2DF2L2D2F2
⇒U2D'L2U'F2L2U'B2L2R2U'L2B2
⇒F2D'R2U2L2B2UF2L2U2F2L2UF2R2
⇒[f1]3
⇒[f2f37]3
⇒[f3f38]3
⇒[f4f39]3
⇒[f5f40]3
⇒[f6f41]3
⇒[f7f42]3
⇒[f8f43]2
⇒[f9f44]2
⇒[f10f45]2
⇒[f11f46]2
⇒[f12f47]2
⇒[f13f48]2
⇒[f14f49]2
⇒[f15f50]2
⇒[f16f51]2
⇒[f17f52]2
⇒[f18f53]2
⇒[f19f54]2
⇒[f20f55]3
⇒[f21f56]4
⇒[f22f57]5
⇒[f23f58]6
⇒[f24f59]7
⇒[f25f60]8
⇒[f26f61]9
⇒[f27f62]9[f27f62]2
⇒[f28f63]9[f28f63]3
⇒[f29f64]9[f29f64]4
⇒[f30f65]2
⇒[f31f66]3
⇒[f32f67]4
⇒[f33f68]5
⇒[f34f69]6
⇒[f35f70]7
rs[f36f71]8

Output se risolvibile: Solved!
Output se irrisolvibile: (vuoto, nessun output)

L'input deve essere formattato come dump cubico cubico (vedere la Debugsezione). Ciò è stato esplicitamente consentito dall'OP.

Spiegazione

Questo programma utilizza l'approccio di utilizzare un algoritmo del diavolo per scorrere su ogni possibile stato del cubo nello stesso gruppo del cubo risolto. Se il cubo è risolvibile, verrà risolto ad un certo punto prima che l'algoritmo sia terminato (supponendo che l' algoritmo che ho usato funzioni correttamente).

Ogni riga che inizia con ⇒(0x84 nella tabella codici di Cubically) è una definizione di funzione; queste funzioni si basano l'una sull'altra per costituire l'attuale algoritmo del diavolo. La prima riga da eseguire è l'ultima:

rs[f36f71]8

rlegge un cubo da stdin e imposta il cubo di memoria su di esso. smette l'interprete in "solvemode", il che significa che esce e stampa Solved!se il cubo viene risolto (dopo essere stato risolto) in qualsiasi momento. Il resto dei comandi (che si ripetono semplicemente f36f718 volte) corrispondono all'algoritmo finale nella parte inferiore della pagina collegata:

(D) = (CP) = (CPT8) = [(CPC8)(CPT7)]8 (3,847,762,288,469,010,006,992 moves)

(D) is the Devil's Algorithm. If you apply it to the cube, it will be solved at some point before you have done the algorithm once. As you can see, it is terribly long, nearly a thousand times more moves than there are possible positions.

Come posso eseguirlo?

Puoi provarlo online , ma quel link non funziona. TIO scadrà quasi sicuramente prima che questo algoritmo finisca (il tempo di esecuzione massimo per un interprete è di 60 secondi). Se il cubo non è risolvibile, questo algoritmo impiegherà fino a 11 milioni di anni per terminare Cubicamente (a ~ 15,2 milioni di mosse al secondo, che è ciò che ottiene il mio IDE Cloud9 ).

Inoltre, è necessaria molta memoria per eseguire 3 mosse di sestilione. Cubicamente può eseguire circa 4 milioni di mosse al secondo, ma molto probabilmente il processo verrà interrotto a causa della memoria sovraccarica . Muore dopo 15 secondi sulla mia VM con 512 MB di memoria. Perché eseguire mosse su una memoria di costi di array flat già allocata? Trovato una perdita di memoria (o venti) e risolto .

Ecco una versione molto più leggibile che si comporta allo stesso modo.

Ma voglio davvero vedere che funziona!

La prima mossa effettiva che viene eseguita nell'algoritmo di questo diavolo è F2, quindi il cubo più veloce da risolvere sarebbe uno che si mescolava con F2:

   000
   000
   555
113222133444
113222133444
113222133444
   000
   555
   555

Questo effettivamente viene eseguito in 0,007 secondi su TIO .

Come può essere migliorato?

Ci sono sicuramente più algoritmi del diavolo; Ho trovato uno che usa meno di un trentesimo delle mosse che fa. Tuttavia, ciò comporterebbe il costo di diverse migliaia di byte (circa 100 MB in più) e diverse decine di ore di conversione di un complesso circuito hamiltoniano in codice cubico.

È anche possibile rimuovere alcune funzioni e inserirle direttamente nel loop in basso. Tuttavia, ho intenzione di sacrificare alcuni byte per una certa leggibilità.

Inoltre, sto prendendo in considerazione una modifica del comportamento del looping di Cubically in modo da poter ripetere più facilmente gli algoritmi 7 o 8 volte (invece di codificarli semplicemente con le chiamate di funzione ripetute 7 o 8 volte nel sorgente). Oppure lavorerò un po 'di magia con il blocco note e giocherò a golf usando più anelli.

Nota che continuerò a ottimizzare qualsiasi cosa possibile nell'interprete, quindi in futuro potrebbe funzionare su un PC medio!

Cubicamente, 2 byte

r▦

Mi piace la risposta di cui sopra, quindi sto aggiungendo questa come soluzione alternativa. Ciò dura meno di un secondo, a differenza di qualche milione di anni.

r    read cube from standard in
 ▦   and solve it

Uscita se il cubo è risolvibile: (nulla)
Uscita se il cubo è irrisolvibile: Error: The cube has reached an unsolvable state.

APL (Dyalog Classic) , 190 174 byte

{∧/~∊(×1 2 3|+.-⌿↑⊃∘⍋¨¨¨a)({2|≢∪{⍵⌊⍵[⍵]}⍣≡⍵,0}¨⍳⌿↑⌽b)((∪≢∩)¨/b←(⊃∘⍋⌽⊢)¨¨¨a),6≢≢∪⊃⊃a←{c←4⍴⊂⍬⋄c[+/1≠i],←(≠/×i←↑⍳3⍴3){⊂⌽⍣⍺⊢⍵~' '}¨,⌿(3|∘.+⍨⍳3)⍉⍤¯1↑1 0 1\⍵⋄1↓c}¨⍵(3 3∘⍴¨1 1∘⌷¨⍵)}

Provalo online!

L'argomento è una matrice 3x2 (riga 0: fronte retro, riga 1: sinistra destra, riga 2: su giù) di matrici di caratteri 3x3. Restituisce 1 per un cubo di Rubik risolvibile, 0 altrimenti.

Nel collegamento TIO, la funzione t, che non è inclusa nel conteggio dei caratteri, legge 9 righe di input, le converte dal formato di input predefinito (una rete) alla matrice 3x2 x 3x3 richiesta, chiama la soluzione e stampa OK se il risultato è come previsto.

L'algoritmo divide il cubo dato in 26 cubetti: stringhe di lunghezza 3 (angoli), 2 (bordi) e 1 (centri). Genera anche i 26 cubi di un cubo risolto con gli stessi 6 cubi centrali. Devono essere soddisfatti tutti i seguenti criteri:

• non ci sono duplicati tra i 6 centri

• gli insiemi di cubi dati / risolti corrispondono, fino alla rotazione, ad esempio considera 'WBR'e 'BRW'lo stesso cubo, ma non'BWR'

• le parità sia della permutazione dell'angolo che della permutazione del bordo sono pari

• il modulo-3 somma degli indici di rotazione angolari (ad esempio prendendo il "piccolo" lettera Bcome punto di riferimento abbiamo: 'BRW'→0, 'WBR'→1, 'RWB'→2) corrispondenza tra le date e risolti cubi; lo stesso per gli angoli modulo 2