Un temps de passage vénéré des pédants est de souligner que les images de "Rubik's Cubes" (sur des t-shirts, des affiches, etc.) ne sont pas réellement résolables.

La première chose à vérifier est que le cube est composé des bonnes pièces. Pour être résoluble, un cube a besoin de six couleurs chacune avec neuf carrés. Le cube a également besoin que chaque unité de bord et de coin (ce sont les plus petits cubes qui composent le cube) soit unique. Non seulement ils doivent être uniques, mais si deux pièces centrales sont opposées, aucune pièce de bord ou d'angle ne peut contenir ces deux couleurs.

Une fois que vous avez un cube composé de toutes les bonnes pièces, vous devez toujours vérifier qu'il peut être résoluble. Il y a quelques règles ici, je vais donc m'en remettre à un expert pour les expliquer, le spoiler ci-dessous explique comment nous pouvons le faire. Si vous souhaitez résoudre le problème par vous-même, vous n'avez pas besoin de visiter le site pour comprendre ou participer à ce défi.

Explication liée

Votre tâche consiste à prendre un modèle en entrée et à déterminer s'il s'agit en fait d'un cube Rubik résoluble. Pour être résoluble, il doit y avoir un moyen d'effectuer des mouvements valides sur un cube afin que le cube n'ait qu'une seule couleur sur chaque face (et que les différentes faces aient des couleurs différentes). La plupart des cubes de Rubik ont ​​une coloration standard (le blanc est opposé au jaune, etc.), vous ne pouvez pas supposer que l'état de résolution suit cette coloration particulière.

Un mouvement valide est la rotation dans le sens horaire ou anti-horaire d'une seule face du cube. Avec la rotation de la face du cube, tous les carrés bordant le visage sont également tournés, restant connectés au visage qu'ils touchaient auparavant.

IO

Vous pouvez prendre le cube de toute manière raisonnable. Si votre langue a un type de "cube-face" intégré, bon pour vous, c'est bien comme entrée, sinon vous pouvez prendre un tableau 2D du filet, du cube, 1 3 par 3 listes pour chaque face. Soyez juste raisonnable. Si vous voulez savoir si un format spécifique est un commentaire acceptable ou envoyez-moi un ping dans le chat et j'ajouterai au défi d'indiquer sa validité.

Votre format d'entrée ne doit prendre en charge que jusqu'à 9 couleurs possibles.

Pour la sortie, c'est un problème de décision, vous devez donc sortir une valeur constante pour "Oui, c'est un cube Rubik valide" et une valeur constante différente pour "Non, ce n'est pas un cube Rubik valide".

Il s'agit de code-golf donc les réponses seront notées en octets avec moins d'octets étant meilleurs.

Cas de test

Voici des cas de test. Ils sont formatés comme le filet d'un cube avec chaque carré comme une seule lettre. Différentes lettres représentent différentes couleurs. D'autres tests peuvent être ajoutés sur demande.

Soluble

   RRR
   RRR
   RRR
GGGWWWBBBOOO
GGGWWWBBBOOO
GGGWWWBBBOOO
   YYY
   YYY
   YYY


   GRR
   GRR
   ORW
WWRBWYBOOGGY
GGRBWGYBBOOO
OOGRWGYWWRBB
   WYO
   YYB
   YYB

Insoluble

   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

Cubiquement , 1664 1631 1089 octets

⇒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

Sortie si résoluble: Solved!
Sortie si insoluble: (vide, pas de sortie)

L'entrée doit être formatée en tant que vidage de cube cubique (voir la Debugsection). Cela a été explicitement autorisé par le PO.

Explication

Ce programme utilise l'approche d'un algorithme du diable pour parcourir tous les états possibles du cube dans le même groupe que le cube résolu. Si le cube est résoluble, il sera résolu à un moment donné avant la fin de l'algorithme (en supposant que l' algorithme que j'ai utilisé fonctionne correctement).

Chaque ligne commençant par ⇒(0x84 dans la page de code de Cubically) est une définition de fonction; ces fonctions s'appuient les unes sur les autres pour constituer l'algorithme du diable réel. La première ligne à exécuter est la dernière:

rs[f36f71]8

rlit un cube depuis stdin et y définit le cube mémoire. smet l'interpréteur en «solvemode», ce qui signifie qu'il se ferme et s'imprime Solved!si le cube est résolu (après avoir été non résolu) à tout moment. Les autres commandes (qui se répètent simplement f36f718 fois) correspondent à l'algorithme final en bas de la page liée:

(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.

Comment puis-je l'exécuter?

Vous pouvez l' essayer en ligne , mais ce lien ne fonctionne pas. TIO expirera presque définitivement avant la fin de cet algorithme (le temps d'exécution maximum pour un interprète est de 60 secondes). Si le cube n'est pas résoluble, cet algorithme prendra jusqu'à 11 millions d'années pour que Cubically se termine (à ~ 15,2 millions de mouvements par seconde, ce que mon IDE Cloud9 obtient).

De plus, vous avez besoin de beaucoup de mémoire pour effectuer 3 mouvements de sextillion. Cubically peut effectuer environ 4 millions de mouvements par seconde, mais le processus sera probablement tué en raison d'une mémoire surchargée . Il meurt après 15 secondes sur ma machine virtuelle avec 512 Mo de mémoire. Pourquoi les déplacements sur une baie plate déjà allouée devraient-ils coûter de la mémoire? Trouvé une fuite de mémoire (ou vingt) et corrigé .

Voici une version beaucoup plus lisible qui se comporte de la même manière.

Mais je veux vraiment voir que ça marche!

Le premier mouvement réel qui est exécuté dans l'algorithme de ce diable est F2, donc le cube le plus rapide à résoudre serait brouillé avec F2:

   000
   000
   555
113222133444
113222133444
113222133444
   000
   555
   555

Cela s'exécute en effet en 0,007 secondes sur TIO .

Comment ça pourrait être amélioré?

Il y a certainement plus d'algorithmes du diable; J'en ai trouvé un qui utilise moins d'un trentième des mouvements de celui-ci. Cependant, cela coûterait plusieurs milliers d'octets (environ 100 Mo de plus) et plusieurs dizaines d'heures de conversion d'un circuit hamiltonien complexe en code cubique.

Il est également possible de supprimer certaines des fonctions et de les mettre directement dans la boucle en bas. Cependant, je vais sacrifier quelques octets pour une certaine lisibilité.

De plus, j'envisage une modification du comportement de bouclage de Cubically afin que je puisse plus facilement répéter les algorithmes 7 ou 8 fois (au lieu de simplement les coder en dur avec les appels de fonction répétés 7 ou 8 fois dans la source). Ou je vais faire de la magie avec le bloc-notes, et jouer au golf en utilisant plus de boucles.

Notez que je continuerai d'optimiser tout ce qui est possible dans l'interpréteur, donc cela peut fonctionner sur un PC moyen dans le futur!

Cubiquement, 2 octets

r▦

J'aime mieux la réponse ci-dessus, donc j'ajoute cela comme une solution alternative. Cela prend moins d'une seconde, contre quelques millions d'années.

r    read cube from standard in
 ▦   and solve it

Sortie si le cube est résoluble: (rien)
Sortie si le cube est insoluble: Error: The cube has reached an unsolvable state.

APL (Dyalog Classic) , 190 174 octets

{∧/~∊(×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∘⌷¨⍵)}

Essayez-le en ligne!

L'argument est une matrice 3x2 (rangée0: avant arrière, rangée1: gauche droite, rangée2: haut en bas) de matrices de caractères 3x3. Renvoie 1 pour un cube Rubik résoluble, 0 sinon.

Dans le lien TIO, la fonction t, qui n'est pas incluse dans le nombre de caractères, lit 9 lignes d'entrée, les convertit du format d'entrée par défaut (un réseau) en la matrice 3x2 x 3x3 requise, appelle la solution et imprime OK si le résultat est comme prévu.

L'algorithme divise le cube donné en 26 cubes - des chaînes de longueur 3 (coins), 2 (bords) et 1 (centres). Il génère également les 26 cubes d'un cube résolu avec les mêmes 6 cubes centraux. Tous les critères suivants doivent être remplis:

• il n'y a pas de doublons parmi les 6 centres

• les ensembles de cubes donnés / résolus correspondent, jusqu'à la rotation - par exemple, considérez 'WBR'et 'BRW'le même cube, mais pas'BWR'

• les parités de la permutation de coin et de la permutation de bord sont égales

• la somme modulo-3 des indices de rotation d'angle (par exemple , en prenant la lettre « plus petit » Bcomme point de référence , nous avons: 'BRW'→0, 'WBR'→1, 'RWB'→2) match entre les cubes donnés et résolus; idem pour les coins modulo 2