रूबिक के साथ साइकिल चलाना


43

मेरे रुबिक के क्यूब को इधर-उधर घुमाते हुए, मेरे बेटे ने देखा कि यह सुलझी हुई अवस्था में वापस जा रहा है। मुझे पूरा यकीन है कि उसने सोचा था कि यह पहली बार जादू जादू था, लेकिन मैंने समझाया कि यदि आप चालों के उसी क्रम को दोहराते रहेंगे, तो यह हमेशा अपनी मूल स्थिति में लौट आएगा। अंततः।

बेशक, एक बच्चा होने के नाते, उसे खुद के लिए इसे आज़माना था और एक "यादृच्छिक" अनुक्रम चुना जिसे उसने सोचा कि यह मुश्किल होगा। उसने दस बार दोहराए जाने के बाद ट्रैक खो दिया, और मुझसे पूछा कि उसे कितनी बार दोहराना होगा। वह जिस अनुक्रम का उपयोग कर रहा था, उसे नहीं जानकर, मैंने उससे कहा कि मुझे नहीं पता, लेकिन यह पता लगाने के लिए हम एक कार्यक्रम लिख सकते हैं।

यह वह जगह है जहाँ आप आते हैं। बेशक, मैं कुछ कोड़ा मार सकता था, लेकिन वह इसे खुद में टाइप करना चाहता था। वह अभी तक बहुत तेज टाइपिस्ट नहीं है, लेकिन मुझे सबसे कम कार्यक्रम की आवश्यकता है

उद्देश्य

क्यूब्स के अनुक्रम को देखते हुए, क्यूब को उसकी मूल स्थिति में वापस करने के लिए सबसे कम संख्या में आउटपुट करना होगा। यह कोड गोल्फ है, इसलिए कम से कम बाइट्स जीतता है। आप एक प्रोग्राम या फ़ंक्शन लिख सकते हैं, और अन्य सभी सामान्य चूक लागू होते हैं।

इनपुट

इनपुट चालों का एक क्रम है, जिसे एक स्ट्रिंग, सूची या आपकी भाषा के लिए उपयुक्त अन्य प्रारूप के रूप में लिया जाता है। स्ट्रिंग रूप में अगर चाल के बीच एक विभाजक (या नहीं) का उपयोग करने के लिए स्वतंत्र महसूस करें।

छह "मूल" चालें हैं जिन्हें अपने आक्रमण के साथ ध्यान में रखा जाना चाहिए:

R - Turn the right face clockwise
L - Turn the left face clockwise
U - Turn the up (top) face clockwise
D - Turn the down (bottom) face clockwise
F - Turn the front face clockwise
B - Turn the back face clockwise

'अक्षर के बाद अभाज्य चिह्न जोड़कर आक्रमणकारियों का प्रतिनिधित्व किया जाता है। यह इंगित करता है कि आप उस चेहरे को वामावर्त मोड़ते हैं, इसलिए F'सामने का चेहरा वामावर्त मुड़ता है, और F F'इसे तुरंत मूल स्थिति में लौटा देगा।

रुचि के लिए, यह चुनौती सिंगमास्टर नोटेशन के सीमित सेट का उपयोग कर रही है । यदि आप इसे कार्रवाई में देखना चाहते हैं तो Ruwix के पास कुछ अच्छे एनिमेशन हैं।

उत्पादन

इनपुट अनुक्रम को निष्पादित करने के लिए आउटपुट केवल न्यूनतम संख्या है।

उदाहरण

Input                Output

FF'               ->      1
R                 ->      4
RUR'U'            ->      6
LLUUFFUURRUU      ->     12
LUFFRDRBF         ->     56
LF                ->    105
UFFR'DBBRL'       ->    120
FRBL              ->    315

जावा में लिखे गए अपने उत्तरों की तुलना करने के लिए यहां एक (काफी भोला) सॉल्वर है। यह 2दोहरी चाल के लिए भी स्वीकार करता है (इसलिए चौथा मामला बराबर है L2U2F2U2R2U2)।

import java.util.ArrayList;
import java.util.List;

public class CycleCounter{

    public static void main(String[] args){
        int[] cube = new int[54];
        for(int i=0;i<54;i++)
            cube[i] = i;

        String test = args.length > 0 ? args[0] : "RUR'U'";
        List<Rotation> steps = parse(test);
        System.out.println(steps.toString());

        int count = 0;
        do{
            for(Rotation step : steps)
                cube = step.getRotated(cube);
            count++;
        }while(!isSorted(cube));

        System.out.println("Cycle length for " + test + " is " + count);        
    }

    static List<Rotation> parse(String in){
        List<Rotation> steps = new ArrayList<Rotation>();
        for(char c : in.toUpperCase().toCharArray())
            switch(c){
                case 'R':steps.add(Rotation.R);break;
                case 'L':steps.add(Rotation.L);break;
                case 'U':steps.add(Rotation.U);break;
                case 'D':steps.add(Rotation.D);break;
                case 'F':steps.add(Rotation.F);break;
                case 'B':steps.add(Rotation.B);break;
                case '\'':
                    steps.add(steps.get(steps.size()-1));
                case '2':
                    steps.add(steps.get(steps.size()-1));
                    break;
            }
        return steps;
    }

    static boolean isSorted(int[] in){for(int i=0;i<in.length-1;i++)if(in[i]>in[i+1])return false;return true;}

    enum Rotation{
        R(new int[]{-1,-1,42,-1,-1,39,-1,-1,36, -1,-1,2,-1,-1,5,-1,-1,8, 20,23,26,19,-1,25,18,21,24, -1,-1,11,-1,-1,14,-1,-1,17, 35,-1,-1,32,-1,-1,29,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1}),
        L(new int[]{9,-1,-1,12,-1,-1,15,-1,-1, 27,-1,-1,30,-1,-1,33,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1, 44,-1,-1,41,-1,-1,38,-1,-1, -1,-1,6,-1,-1,3,-1,-1,0, 47,50,53,46,-1,52,45,48,51}),
        U(new int[]{2,5,8,1,-1,7,0,3,6, 45,46,47,-1,-1,-1,-1,-1,-1, 9,10,11,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1, 18,19,20,-1,-1,-1,-1,-1,-1, 36,37,38,-1,-1,-1,-1,-1,-1}),
        D(new int[]{-1,-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,24,25,26, -1,-1,-1,-1,-1,-1,42,43,44, 29,32,35,28,-1,34,27,30,33, -1,-1,-1,-1,-1,-1,51,52,53, -1,-1,-1,-1,-1,-1,15,16,17}),
        F(new int[]{-1,-1,-1,-1,-1,-1,18,21,24, 11,14,17,10,-1,16,9,12,15, 29,-1,-1,28,-1,-1,27,-1,-1, 47,50,53,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,8,-1,-1,7,-1,-1,6}),
        B(new int[]{51,48,45,-1,-1,-1,-1,-1,-1, -1,-1,-1,-1,-1,-1,-1,-1,-1, -1,-1,0,-1,-1,1,-1,-1,2, -1,-1,-1,-1,-1,-1,26,23,20, 38,41,44,37,-1,43,36,39,42, 33,-1,-1,34,-1,-1,35,-1,-1});

        private final int[] moves;
        Rotation(int[] moves){
            this.moves = moves;
        }

        public int[] getRotated(int[] cube){
            int[] newCube = new int[54];
            for(int i=0;i<54;i++)
                if(moves[i]<0)
                    newCube[i] = cube[i];
                else
                    newCube[moves[i]] = cube[i];
            return newCube;
        }
    }
}

"दक्षिणावर्त" का अर्थ है "जब आप इसका सामना कर रहे हैं तो दक्षिणावर्त" मैं मानता हूं?
msh210

@ msh210 सही।
जियोबिट्स

7
पैदल सेना के एक बिंदु पर, मुझे लगता है कि आपको यह स्पष्ट करना चाहिए कि आप सबसे छोटी संख्या चाहते हैं जो पर्याप्त है। अन्यथा मैं सिर्फ समूह के आकार का उत्पादन कर सकता था और लाग्रेंज के प्रमेय का हवाला देता ...
पीटर टेलर

2
@PeterTaylor पैदल सेना ने स्वीकार किया।
21

4
मैं शफल में समाधान के लिए 500 अंक का इनाम दे सकता हूं । अभी तक यकीन नहीं।
lirtosiast

जवाबों:


16

पायथ, 66 63 बाइट्स

l.uum.rW}Hdd@_sm_B.iFP.>c3Zk3xZHG_r_Xz\'\39Nf!s}RTcZ2y=Z"UDLRFB

इसे ऑनलाइन आज़माएँ: प्रदर्शन या टेस्ट सूट । ध्यान दें कि प्रोग्राम थोड़े धीमा है और ऑनलाइन कंपाइलर इसके लिए उत्तर की गणना करने में सक्षम नहीं है RU2D'BD'। लेकिन आश्वस्त रहें, कि यह मेरे लैपटॉप पर लगभग 12 सेकंड में गणना कर सकता है।

कार्यक्रम (गलती से) 2दोहरे चाल के लिए भी स्वीकार करता है।

पूर्ण व्याख्या:

पार्स हाथापाई:

पहले मैं 'इनपुट स्ट्रिंग्स में प्रमुख चिह्नों से निपटूंगा। मैं बस के साथ उन्हें बदलने के लिए 3और रन-लंबाई इस स्ट्रिंग को डिकोड करता हूं । चूंकि पायथ के डिकोडिंग प्रारूप में चार के सामने संख्या की आवश्यकता होती है, इसलिए मैं पहले से स्ट्रिंग को उल्टा कर देता हूं। _r_Xz\'\39। इसलिए बाद में मैंने इसे उल्टा कर दिया।

हल घन अवस्था का वर्णन करें:

=Z"UDLRFBसभी 6 चालों के साथ स्ट्रिंग प्रदान करता है Z

हम प्रत्येक क्यूब के टुकड़े के लिए स्थान का वर्णन करके एक घन अवस्था का वर्णन कर सकते हैं। उदाहरण के लिए हम कह सकते हैं कि किनारे, जो कि UL (ऊपर-बाएं) में होना चाहिए, वर्तमान में FR (फ्रंट-राइट) पर है। इसके लिए मुझे हल किए गए घन के सभी टुकड़ों को उत्पन्न करने की आवश्यकता है f!s}RTcZ2yZ:। yZके सभी संभावित सबसेट उत्पन्न करता है "UDLRFB"। यह स्पष्ट रूप से सबसेट "UDLRFB"और सबसेट भी उत्पन्न करता है "UD"। पहला वाला कोई मतलब नहीं रखता है, क्योंकि कोई भी टुकड़ा नहीं है जो सभी 6 तरफ से दिखाई दे रहा है, और दूसरा कोई मतलब नहीं है, क्योंकि कोई किनारे नहीं है, जो ऊपर और नीचे से दिखाई देता है। । इसलिए मैं सभी सबसेट, कि परिणाम को शामिल हटाने "UD", "LR"या "FB"। यह मुझे निम्नलिखित 27 टुकड़े देता है:

'', 'U', 'D', 'L', 'R', 'F', 'B', 'UL', 'UR', 'UF', 'UB', 'DL', 'DR', 'DF', 'DB', 
'LF', 'LB', 'RF', 'RB', 'ULF', 'ULB', 'URF', 'URB', 'DLF', 'DLB', 'DRF', 'DRB'

इसमें खाली स्ट्रिंग और सभी छह 1-अक्षर तार भी शामिल हैं। हम उन्हें क्यूब और 6 केंद्र के टुकड़ों के बीच में टुकड़े के रूप में व्याख्या कर सकते हैं। जाहिर है कि उनकी आवश्यकता नहीं है (क्योंकि वे नहीं चलते हैं), लेकिन मैं उन्हें रखूँगा।

कुछ चालें करना:

मैं एक चाल प्रदर्शन करने के लिए कुछ स्ट्रिंग अनुवाद करूँगा। विचार को देखने के लिए कोने के टुकड़े को देखें URF। क्या होता है, जब मैं एक Rचाल है? Uचेहरे पर स्टिकर चेहरे पर चला जाता है B, स्टिकर चेहरे पर चला Fजाता है और Uचेहरे पर स्टिकर Rचेहरे पर रहता है R। हम कह सकते हैं, कि टुकड़ा URFस्थिति में चला जाता है BRU। यह पैटर्न सही पक्ष पर सभी टुकड़ों के लिए सही है। हर स्टीकर पर है कि Fकरने के लिए चेहरा चाल Uचेहरा जब एक Rकदम किया जाता है, हर स्टीकर पर है कि Uकरने के लिए चेहरा चाल Bचेहरा, पर हर स्टीकर Bपर ले जाता है Dपर और हर स्टीकर Dपर ले जाता हैF। हम एक Rचाल के परिवर्तन को डिकोड कर सकते हैं FUBD

निम्नलिखित कोड सभी 6 आवश्यक कोड उत्पन्न करता है:

_sm_B.iFP.>c3Zk3
['BRFL', 'LFRB', 'DBUF', 'FUBD', 'RDLU', 'ULDR']
    ^       ^       ^       ^       ^       ^
 U move  D move  L move  R move  F move  B move

और हम Hनिम्नलिखित के Gरूप में घन राज्य के लिए एक चाल प्रदर्शन :

m.rW}Hdd@...xZHG
m              G   map each piece d in G to:
 .rW   d              perform a rotated translation to d, but only if:
    }Hd                  H appears in d (d is currently on the face H)
            xZH           get the index of H in Z
        @...              and choose the code in the list of 6 (see above)

दोहराने की संख्या की गणना करें:

बाकी सब बहुत ज्यादा तुच्छ है। मैं तब तक हल किए गए घन पर इनपुट स्क्रैम्बल का प्रदर्शन करता हूं, जब तक कि मैं उस स्थिति तक नहीं पहुंच जाता हूं जिसे मैंने पहले देखा था।

l.uu<apply move H to G><parsed scramble>N<solved state>
u...N   performs all moves of the scramble to the state N
.u...   do this until cycle detected, this returns all intermediate states
l       print the length

13

जीएपी, 792 783 782 749 650 बाइट्स

यह काम करने लगता है। अगर यह किसी चीज से खिलवाड़ करता है तो मुझे बताएं।

सुझाव के लिए @Lynn का धन्यवाद कि मैंने कुछ आदिम चालों का विरोध किया।

सुझाव के बजाय @ उपयोग के लिए धन्यवाद कि Inverse(X)मैं इसके बजाय उपयोग करता हूं X^3

उपयोग उदाहरण: f("R");

R:=(3,39,21,48)(6,42,24,51)(9,45,27,54)(10,12,18,16)(13,11,15,17);L:=(1,46,19,37)(4,49,22,40)(7,52,25,43)(30,36,34,28)(29,33,35,31);U:=(1,10,27,28)(2,11,26,29)(3,12,25,30)(37,43,45,39)(40,44,42,38);A:=R*L^3*F*F*B*B*R*L^3;D:=A*U*A;;F:=(1,3,9,7)(2,6,8,4)(10,48,36,43)(13,47,33,44)(16,46,30,45);B:=(27,25,19,21)(26,22,20,24)(39,28,52,18)(38,31,53,15)(37,34,54,12);d:=NewDictionary((),true);AddDictionary(d,'R',R);AddDictionary(d,'L',L);AddDictionary(d,'U',U);AddDictionary(d,'D',D);AddDictionary(d,'F',F);AddDictionary(d,'B',B);f:=function(s) local i,p,b,t;p:=();
for c in s do if c='\'' then t:=t^2;else t:=LookupDictionary(d,c);fi;p:=p*t;od;return Order(p);end;

यहाँ थोड़ा सा स्पष्टीकरण के साथ असम्बद्ध कोड है

  # Here we define the primitive moves
R:=(3,39,21,48)(6,42,24,51)(9,45,27,54)(10,12,18,16)(13,11,15,17);
L:=(1,46,19,37)(4,49,22,40)(7,52,25,43)(30,36,34,28)(29,33,35,31);
U:=(1,10,27,28)(2,11,26,29)(3,12,25,30)(37,43,45,39)(40,44,42,38);
#D:=(7,34,21,16)(8,35,20,17)(9,36,19,18)(48,46,52,54)(47,49,53,51);
F:=(1,3,9,7)(2,6,8,4)(10,48,36,43)(13,47,33,44)(16,46,30,45);
B:=(27,25,19,21)(26,22,20,24)(39,28,52,18)(38,31,53,15)(37,34,54,12);

# Here we define D in terms of other primitive moves, saving on bytes
# Thanks @Lynn
# This is actually doable with a maximum of 3 of the primitive moves
# if a short enough sequence can be found.
D:=U^(R*L^3*F*F*B*B*R*L^3);

# create dictionary and add moves to it with appropriate char labels
d:=NewDictionary((),true);
AddDictionary(d,'R',R);
AddDictionary(d,'L',L);
AddDictionary(d,'U',U);
AddDictionary(d,'D',D);
AddDictionary(d,'F',F);
AddDictionary(d,'B',B);

f:=function(s)
    local c,p,t;

    # p will become the actual permutation passed to the function
    p:=();

    for c in s do
        if c='\'' then
            # The last generator we mutiplied (that we still have in t)
            # should have been its inverse. Compensate by preparing to
            # multiply it two more times to get t^3=t^-1. Thanks @Neil.
            t:=t^2;
        else
            t:=LookupDictionary(d,c);
        fi;
        p:=p*t;
    od;

    return Order(p);

end;

हर चाल पहचान का चौथा मूल है, इसलिए आपका व्युत्क्रम अनावश्यक है।
नील

आप शायद अपने क्रमपरिवर्तन के 45साथ बदल सकते 5हैं, और तीन बाइट्स बचा सकते हैं।
लिन

बेन्सन का एक परिणाम मुझे सिंगमास्टर में मिला, 1981 कहता है: "A A = RL²F BB²RL I, तब AUA = D." वास्तव में, A:=R*L*L*L*F*F*B*B*R*L*L*L;D:=A*U*A;आपकी परिभाषा से छोटा है D(लेकिन मैं इसका परीक्षण नहीं कर सकता ...)
लिन

क्या GAP वास्तव में आपको ^-1उलटा, BTW के लिए लिखने नहीं देता है ?
लिन

हाँ, मैं ^ -1 का उपयोग करने में पूरी तरह से लगा हुआ हूं। जो मुझे लगता है कि बहुत ज्यादा वही बात थी @ नील कह रही थी, सिवाय ^ 3 के बजाय (जो वास्तव में सबसे छोटा है)। इसके अलावा, हाँ, मैं अन्य चालों में चालों को विघटित कर सकता हूं, और मुझे ऐसा करके कई बाइट्स बचाने में सक्षम होना चाहिए, यह केवल सबसे कम अपघटन खोजने का मामला होगा।
लियाम

10

गणितज्ञ, 413 401 बाइट्स

Evaluate[f/@Characters@"RFLBUD"]=LetterNumber@"ABFEJNRMDAEHIMQPCDHGLPTOBCGFKOSNADCBILKJEFGHQRST"~ArrayReshape~{6,2,4};
r[c_,l_]:=(b=Permute[c,Cycles@f@l];MapThread[(b[[#,2]]=Mod[b[[#,2]]+{"F","B","L","R"}~Count~l{-1,1,-1,1},#2])&,{f@l,{3,2}}];b);
p@s_:=Length[c={#,0}&~Array~20;NestWhileList[Fold[r,#,Join@@StringCases[s,x_~~t:""|"'":>Table[x,3-2Boole[t==""]]]]&,c,(Length@{##}<2||c!=Last@{##})&,All]]-1

स्पष्टीकरण

एक रुबिक का घन 20 जंगम घन (8 कोने, 12 किनारों) के साथ बना है। प्रत्येक घन को एक नंबर दिया जा सकता है:

कोनों :

N   starting position
1     UFR
2     UBR
3     UBL
4     UFL
5     DFR
6     DBR
7     DBL
8     DFL

किनारों :

N   starting position
9     UF
10    UR
11    UB
12    UL
13    FR
14    BR
15    BL
16    FL
17    DF
18    DR
19    DB
20    DL

ध्यान दें कि जब क्यूब को घुमाया जाता है, तो क्यूब्स आम तौर पर अपने शुरुआती पदों पर नहीं होते हैं। उदाहरण के लिए, जब Rकिया जाता है, cubie 1से चलता रहता है UFRकिसी नए स्थान पर UBR

इस तरह के अंकन में, क्यूब्स के 8 आंदोलनों द्वारा एक 90 डिग्री मोड़ का वर्णन किया जा सकता है। उदाहरण के लिए, Rद्वारा वर्णित है

from  to
UFR   UBR
UBR   DBR
DBR   DFR
DFR   UFR
UR    BR
BR    DR
DR    FR
FR    UR

चूंकि प्रत्येक क्यूबाई में एक अद्वितीय प्रारंभिक स्थिति होती है, इसलिए प्रत्येक स्थिति में एक अद्वितीय शुरुआती क्यूबी होता है। यही कारण है कि शासन कहने के लिए है, UFR->UBRबस है 1->2(इसका मतलब है कि Rcubie की प्रारंभिक स्थिति पर cubie लेता 1cubie की प्रारंभिक स्थिति के लिए 2)। इस प्रकार, Rआगे एक चक्र तक सरलीकृत किया जा सकता है

Cycles[{{1,2,6,5}, {10,14,18,13}}]

रुबिक के क्यूब को पूरी तरह से हल करने के लिए, हमें क्यूबियों को उनके संबंधित शुरुआती झुकावों के साथ संरेखित करने की आवश्यकता है। क्यूब के चेहरों को अलग-अलग रंगों में चित्रित किया जाता है, जो योजना मैं अक्सर क्यूब्स को हल करते समय उपयोग करता हूं

face color
U    yellow
D    white
F    red
B    orange
R    green
L    blue

जब हम कोनों के झुकाव का विश्लेषण करते हैं, तो पीले या सफेद के अलावा अन्य रंगों को अनदेखा किया जाता है, और पीले और सफेद को एक ही रंग माना जाता है।

मान लीजिए कि क्यूबाई 1अपने शुरुआती स्थान पर है UFR, पीला पहलू तीन अलग-अलग चेहरों के साथ जोड़ा जा सकता है। हम इन मामलों का प्रतिनिधित्व करने के लिए एक पूर्णांक का उपयोग करते हैं,

0  yellow on U  (correct)
1  yellow on R  (120 degree clockwise)
2  yellow on F  (120 degree counterclockwise)

मान लीजिए क्यूबाई चालू 1है DFL, इसके तीन संभावित झुकाव हैं

0  yellow on D  (correct)
1  yellow on L  (120 degree clockwise)
2  yellow on F  (120 degree counterclockwise)

जब हम किनारों के झुकाव का विश्लेषण करते हैं, तो लाल और नारंगी को नजरअंदाज कर दिया जाता है, और पीले और सफेद को केवल तभी नजरअंदाज कर दिया जाता है, जब किनारे पर एक हरा या नीला पहलू होता है।

मान लीजिए कि क्यूबाई 10अपने शुरुआती स्थान पर है UR, हरे रंग के चेहरे को दो अलग-अलग चेहरों के साथ जोड़ा जा सकता है। इसके दो संभावित झुकाव हैं

0  green on R  (correct)
1  green on U  (180 degree)

मान लीजिए कि क्यूबाई चालू 10है DF, इसके दो संभावित झुकाव हैं

0  green on D  (correct)
1  green on F  (180 degree)

एक सरणी का उपयोग घन की स्थिति को संग्रहीत करने के लिए किया जाता है। एक घन की प्रारंभिक अवस्था है

{{1,0},{2,0},{3,0},{4,0},{5,0},{6,0},{7,0},{8,0},{9,0},{10,0},{11,0},{12,0},{13,0},{14,0},{15,0},{16,0},{17,0},{18,0},{19,0},{20,0}}

जिसका अर्थ है कि प्रत्येक घन सही अभिविन्यास के साथ अपनी प्रारंभिक स्थिति पर हैं।

के बाद R, घन की स्थिति बन जाती है

{{5,2},{1,1},{3,0},{4,0},{6,1},{2,2},{7,0},{8,0},{9,0},{13,1},{11,0},{12,0},{18,1},{10,1},{15,0},{16,0},{17,0},{14,1},{19,0},{20,0}}

जिसका अर्थ है कि क्यूबी 5अब अभिविन्यास के साथ स्थिति 1( UFR) पर है 2, क्यूबी 1अब स्थिति पर है 2( UBR) अभिविन्यास के साथ 1, क्यूबी 3अब भी स्थिति पर है 3( UBL) अभिविन्यास के साथ 0, और इसी तरह।


परीक्षण के मामलों

p["FF'"]            (* 1   *)
p["R"]              (* 4   *)
p["RUR'U'"]         (* 6   *)
p["LLUUFFUURRUU"]   (* 12  *)
p["LUFFRDRBF"]      (* 56  *)
p["LF"]             (* 105 *)
p["UFFR'DBBRL'"]    (* 120 *)
p["FRBL"]           (* 315 *)

7

हास्केल, 252 बाइट्स

r=[-2..2]
s=mapM id[r,r,r]
t m p@[x,y,z]=case m of"R"|x>0->[x,z,-y];"L"|x<0->[x,-z,y];"U"|y>0->[-z,y,x];"D"|y<0->[z,y,-x];"F"|z>0->[y,-x,z];"B"|z<0->[-y,x,z];c:"'"->t[c]$t[c]$t[c]p;_->p
f m=length$s:fst(span(/=s)$tail$iterate(flip(foldl$flip$map.t)m)s)

नमूना चलता है:

*Main> f ["F","F'"]
1
*Main> f ["R"]
4
*Main> f ["R","U","R'","U'"]
6
*Main> f ["L","L","U","U","F","F","U","U","R","R","U","U"]
12
*Main> f ["L","U","F","F","R","D","R","B","F"]
56
*Main> f ["L","F"]
105
*Main> f ["U","F","F","R'","D","B","B","R","L'"]
120
*Main> f ["F","R","B","L"]
315
*Main> f ["R","U","U","D'","B","D'"]  -- maximum possible order
1260

यहाँ मुख्य अवलोकन यह है कि रुबिक के क्यूब को 3 × 3 × 3 ग्रिड के बजाय उन्मुख क्यूब के 5 × 5 × 5 ग्रिड के रूप में मॉडल करना सरल है। कॉर्नर क्यूब्स 2 × 2 × 2 पॉइंट के क्यूब्स बन जाते हैं, एज क्यूब 2 × 2 × 1 पॉइंट के स्क्वायर बन जाते हैं, और 5 × 5 × 2 पॉइंट्स के रोटेट स्लाइस हो जाते हैं।


यह वास्तव में चतुर है! मुझे लगता है कि दो बाइट्स को बदलने के c:"'"साथ प्रतिस्थापित किया जाता c:_है।
लिन

धन्यवाद! मैं परीक्षण मामलों के लिए एक 1260 अनुक्रम की तलाश कर रहा था, लेकिन इसे परेशान नहीं किया जा सकता था :)
Geobits

@ लियन, वह काम नहीं करता क्योंकि _खाली सूची से भी मेल खाता है।
एंडर्स कासोर्ग

यह बहुत अच्छा है, लेकिन यह एक अन्य प्रश्न codegolf.stackexchange.com/a/44775/15599 के उत्तर के समान है । यदि आप इससे प्रेरित थे तो आपको इसे स्वीकार करना चाहिए।
लेवल रिवर सेंट

@steveverrill, वाह, यह प्रभावशाली रूप से समान दिखता है, लेकिन नहीं, मैंने इसे नहीं देखा था। मेरा जवाब मेरा अपना स्वतंत्र काम है। (मैं स्वीकार करता हूं, निश्चित रूप से, कि मेरे द्वारा किए जाने से पहले
जनता

7

रूबी, 225 बाइट्स

->s{n=0
a=[]
b=[]
64.times{|i|a<<j=[(i&48)-16,(i&12)-4,i%4-1];b<<j*1}
d=1
(n+=1
s.reverse.chars{|c|m="UFRDBL".index(c)
m ?(e=m/3*2-1
b.each{|j|j[m%=3]*e>0&&(j[m-2],j[m-1]=j[m-1]*e*d,-j[m-2]*e*d)}
d=1):d=-1})until n>0&&a==b
n}

एंडर्स कासोर्ग के उत्तर के समान और जन ड्वोरक के पिछले प्रश्न के उत्तर से प्रेरित ।

हालाँकि उन उत्तरों के विपरीत, मुझे 125 क्यूबियों की आवश्यकता नहीं है। मैं 27 क्यूबियों के एक क्यूबिक क्यूब का उपयोग करता हूं, लेकिन आयताकार आयाम। हल किए गए राज्य में कोनों पर हैं +/-1,+/-4,+/-16

मैं 64 क्यूबियों की एक सरणी उत्पन्न करता हूं, प्रत्येक से चुना गया एक केंद्र x=[-1,0,1,2], y=[-4,0,4,8], z=[-16-0,16,32]। 2, 8 और 32 के निर्देशांक वाले घन अनावश्यक हैं, लेकिन उन्हें कोई नुकसान नहीं होता है, इसलिए उन्हें गोल्फ कारणों से छोड़ दिया जाता है। यह तथ्य कि क्यूब्स की लंबाई, चौड़ाई और गहराई अलग-अलग हैं: (1,4,16) का मतलब यह पता लगाना आसान है कि क्या वे सही जगह पर हैं लेकिन गलत अभिविन्यास के साथ।

प्रत्येक क्यूबाई को ट्रैक किया जाता है क्योंकि इसे faceturns द्वारा स्थानांतरित किया जाता है। यदि चेहरे के अनुरूप अक्ष में एक क्यूबी का समन्वय ( e=-1यू, एफ, आर या e=1डी, बी, एल के लिए गुणा ) सकारात्मक है, तो इसे अन्य 2 अक्ष में निर्देशांक को स्वैप करके और घुमाकर घुमाया जाएगा निर्देशांक में से एक में उचित संकेत परिवर्तन। इसके द्वारा गुणा करके नियंत्रित किया जाता है e*d

इनपुट अनुक्रम रिवर्स ऑर्डर में स्कैन किया जाता है। इससे कोई फर्क नहीं पड़ता, इसलिए जब तक "सामान्य" घुमावों को दक्षिणावर्त के बजाय एंटीक्लॉकवाइज किया जाता है। इसका कारण यह है कि यदि कोई 'प्रतीक पाया जाता है, dतो विपरीत दिशा में निम्नलिखित चेहरे के रोटेशन का कारण बनने के लिए मूल्य को 1 से -1 में बदला जा सकता है।

परीक्षण कार्यक्रम में अपराजित

f=->s{n=0                                      #number of repeats=0
  a=[]                                         #empty array for solved position
  b=[]                                         #empty array for current position
  64.times{|i|
    a<<j=[(i&48)-16,(i&12)-4,i%4-1]            #generate 64 cubies and append them to the solved array
    b<<j*1                                     #duplicate them and append to active array
  }
  d=1                                          #default rotation direction anticlockwise (we scan the moves in reverse)                              
  (                                            #start of UNTIL loop
    n+=1                                       #increment repeat counter
    s.reverse.chars{|c|                        #reverse list of moves and iterate through it
      m="UFRDBL".index(c)                      #assign move letter to m (for ' or any other symbol m is false)
      m ?                                      #if a letter
        (e=m/3*2-1                             #e=-1 for UFR, 1 for DBL
        b.each{|j|                             #for each cubie 
          j[m%=3]*e>0&&                        #m%=3 picks an axis. If the cubie is on the moving face of the cube
         (j[m-2],j[m-1]=j[m-1]*e*d,-j[m-2]*e*d)#rotate it: exchange the coordinates in the other 2 axes and invert the sign of one of them according to direction
        }                                      #as per the values of e and d. 
        d=1                                    #set d=1 (in case it was -1 at the start of the b.each loop)
      ):
      d=-1                                     #ELSE the input must be a ', so set d=-1 to reverse rotation of next letter
    }
   )until n>0&&a==b                            #end of UNTIL loop. continue until back at start position a==b
n}                                             #return n

p f["FF'"]               #      1
p f["R"]                 #      4
p f["RUR'U'"]            #      6
p f["LLUUFFUURRUU"]      #     12
p f["LUFFRDRBF"]         #     56
p f["LF"]                #    105
p f["UFFR'DBBRL'"]       #    120
p f["FRBL"]              #    315

7

पायथन 2, 343 बाइट्स

def M(o,v,e):
 k=1
 for m in e:
  for c in'ouf|/[bPcU`Dkqbx-Y:(+=P4cyrh=I;-(:R6'[m::6]:i=~ord(c)%8*k;j=(ord(c)/8-4)*k;o[i],o[j]=o[j]-m/2,o[i]+m/2;v[i],v[j]=v[j],v[i];k=-k
V=range(20)
o,v,e=[0]*20,V[:],[]
for c in raw_input():i='FBRLUD'.find(c);e+=i<0and e[-1:]*2or[i]
M(o,v,e);n=1
while any(o[i]%(2+i/12)for i in V)or v>V:M(o,v,e);n+=1
print n

इनपुट स्टड से लिया गया है।

जब तक यह सुलझी हुई स्थिति में वापस नहीं आता, तब तक आभासी क्यूब पर बार-बार मुड़ने का क्रम दिया जाता है। घन अवस्था को अभिविन्यास वेक्टर और क्रमपरिवर्तन वेक्टर के रूप में संग्रहीत किया जाता है, दोनों की लंबाई 20 है।

अभिविन्यास कुछ हद तक मनमाने ढंग से परिभाषित कर रहे हैं: एक धार क्यूबी सही ढंग से उन्मुख है अगर यह एक आर या एक चौथाई मोड़ को लागू किए बिना जगह में ले जाया जा सकता है। कोने के क्यूब्स का उन्मुखीकरण एफ और बी चेहरे के सापेक्ष माना जाता है।


नमूना उपयोग

$ echo FRBL|python rubiks-cycle.py
315

$ echo RULURFLF|python rubiks-cycle.py
1260

ऑनलाइन प्रदर्शन और टेस्ट सूट


3
फ़ंक्शन नाम और तर्कों का अच्छा विकल्प!
नील

3

क्लोजर, 359 बाइट्स

यह मेरा दूसरा सबसे लंबा कोडगोल्फ हो सकता है। यह महसूस करते हुए मैं वैक्टर से शून्य अनुगामी छोड़ सकता है Aके लिए Fमुझे बहुत खुश कर दिया: डी

#(let[I(clojure.string/replace % #"(.)'""$1$1$1")D(range -2 3)S(for[x D y D z D][x y z])A[0 1]B[0 0 1]C[1]D[-1]E[0 -1]F[0 0 -1]](loop[P S[[n R]& Q](cycle(map{\F[A[B A D]]\B[E[F A C]]\L[D[C B E]]\R[C[C F A]]\U[B[E C B]]\D[F[A D B]]}I))c 0](if(=(> c 0)(= P S))(/ c(count I))(recur(for[p P](if(>(apply +(map * n p))0)(for[r R](apply +(map * r p)))p))Q(inc c)))))

कम गोल्फ वाला:

(def f #(let [I (clojure.string/replace % #"(.)'""$1$1$1")
              D [-2 -1 0 1 2]
              S (for[x D y D z D][x y z])
              L   {\F [[ 0  1  0][[0  0  1][ 0 1  0][-1  0 0]]]
                   \B [[ 0 -1  0][[0  0 -1][ 0 1  0][ 1  0 0]]]
                   \L [[-1  0  0][[1  0  0][ 0 0  1][ 0 -1 0]]]
                   \R [[ 1  0  0][[1  0  0][ 0 0 -1][ 0  1 0]]]
                   \U [[ 0  0  1][[0 -1  0][ 1 0  0][ 0  0 1]]]
                   \D [[ 0  0 -1][[0  1  0][-1 0  0][ 0  0 1]]]}]
          (loop [P S c 0 [[n R] & Q] (cycle(map L I))]
            (if (and (> c 0) (= P S))
              (/ c (count I))
              (recur (for[p P](if(pos?(apply +(map * n p)))
                                (for[r R](apply +(map * r p)))
                                p))
                     (inc c)
                     Q)))))

यह बस 5 x 5 x 5घन के चयनित सबसेट के 3 डी घुमाव को लागू करता है । मूल रूप से मैं उपयोग करने जा रहा था 3 x 3 x 3और मुझे यह महसूस करने में थोड़ा समय लगा कि मुझे सही परिणाम क्यों नहीं मिल रहे हैं। अच्छी परीक्षा के मामले! मुट्ठी एन्कोडिंग के लिए कुछ अतिरिक्त बाइट्स के "RUR'U'"रूप में "RURRRUUU"


3

मूल रूप से , ६ बाइट्स

¶-7)8%

इसे ऑनलाइन आज़माएं!(जब तक डेनिस ने TIO को मूल रूप से दुभाषिया अपडेट नहीं किया है, तब तक)

स्पष्टीकरण:

¶-7)8%
¶       read a string, insert into code
 -7     add 1 to notepad (subtracts the 7th face "sum" from notepad, defaulted to -1)
   )8   jump back to start of code if cube unsolved
     %  print notepad

यह भाषा सभी चुनौतियों>: डी पर हावी होगी


3
ये सब नए-नए उलझे हुए एंगल। वापस मेरे दिन में, -7इसका मतलब है कि सात को जोड़ना नहीं है एक
agrily

@cairdcoinheringaahing वास्तव में। : पी उस के आसपास कुछ स्पष्टीकरण जोड़ा गया।
एमडी एक्सएफ

1

साफ , 255 बाइट्स

इस प्रश्न के उत्तर के रूप में लगभग समान-हास्केल उत्तर से अलग व्युत्पन्न किया गया था, जो एक डुप्लिकेट के रूप में बंद हो गया था जब यह लगभग समाप्त हो गया था, इसलिए मैंने यहां उत्तर पोस्ट किया।

import StdEnv,StdLib
a=[-2..2];b=diag3 a a a
?m=iter(size m*2-1)\p=:(x,y,z)=case m.[0]of'F'|z>0=(y,~x,z);'U'|y>0=(~z,y,x);'R'|x>0=(x,z,~y);'B'|z<0=(~y,x,z);'D'|y<0=(z,y,~x);'L'|x<0=(x,~z,y);_=p
$l=length(takeWhile((<>)b)(tl(iterate(map(sseq(map?l)))b)))+1

इसे ऑनलाइन आज़माएं!

हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.