रूबिक के घन का अनुकरण करें

39

एक रूबिक के घन में 6 रंग होते हैं: लाल, नारंगी, पीला, सफेद, नीला और हरा। लाल और नारंगी, पीले और सफेद, और नीले और हरे चेहरे विपरीत पक्षों पर हैं।

एक हल रुबिक के घन का नेट इस तरह दिखता है:

 Y
BRGO
 W

और टाइल इस तरह दिखते हैं:

      Y Y Y
      Y Y Y
      Y Y Y
B B B R R R G G G O O O
B B B R R R G G G O O O
B B B R R R G G G O O O
      W W W
      W W W
      W W W

चुनौती

घूर्णन को देखते हुए, प्रत्यावर्तित घूर्णन, या डबल रोटेशन आउटपुट, जो एक हल किया हुआ घन ASCII कला के रूप में या एक छवि के रूप में परिवर्तित हो जाएगा (व्हाट्सएप आवश्यक नहीं है, मौजूद हो सकता है या नहीं हो सकता है, अनुगामी व्हाट्सएप की अनुमति है।)।

इनपुट रोटेशन (और वैकल्पिक संशोधक) होगा। रोटेशन नोटेशन इस प्रकार है: U(पी), L(ईएफटी), F(आरओटी), R(ight), B( एईसी ), D(खुद); 2(डबल), 'या i(उलटा)।

सभी सामान्य घुमाव 90 ° दक्षिणावर्त होंगे, प्रतिलोम वामावर्त होंगे।

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

इनपुट

इनपुट चालों की एक सूची होगी।

उत्पादन

एक ASCII कला जो घन का जाल का चित्र या घन का प्रतिनिधित्व करती है।

उदाहरण

इनपुट : (खाली)

आउटपुट :

      Y Y Y
      Y Y Y
      Y Y Y
B B B R R R G G G O O O
B B B R R R G G G O O O
B B B R R R G G G O O O
      W W W
      W W W
      W W W

इनपुट : U(ऊपर)

आउटपुट :

      Y Y Y
      Y Y Y
      Y Y Y
R R R G G G O O O B B B
B B B R R R G G G O O O
B B B R R R G G G O O O
      W W W
      W W W
      W W W

इनपुट : U'या Ui(उलटा)

आउटपुट :

      Y Y Y
      Y Y Y
      Y Y Y
O O O B B B R R R G G G
B B B R R R G G G O O O
B B B R R R G G G O O O
      W W W
      W W W
      W W W

इनपुट : U2(डबल अप)

आउटपुट :

      Y Y Y
      Y Y Y
      Y Y Y
G G G O O O B B B R R R
B B B R R R G G G O O O
B B B R R R G G G O O O
      W W W
      W W W
      W W W

इनपुट : L'(बाएं छोड़ा गया)

आउटपुट :

      R Y Y
      R Y Y
      R Y Y
B B B W R R G G G O O Y
B B B W R R G G G O O Y
B B B W R R G G G O O Y
      O W W
      O W W
      O W W

इनपुट : R(दाएं)

आउटपुट :

      Y Y R
      Y Y R
      Y Y R
B B B R R W G G G Y O O
B B B R R W G G G Y O O
B B B R R W G G G Y O O
      W W O
      W W O
      W W O

इनपुट : U2 L' D(डबल अप, इनवर्स लेफ्ट, डाउन)

आउटपुट :

      O Y Y
      R Y Y
      R Y Y
G B B W O O B B B R R Y
G B B W R R G G G O O Y
O O Y G B B W R R G G G
      R O O
      W W W
      W W W

नियम

  • कोई खामियों की अनुमति नहीं है।
  • यह कोड-गोल्फ है , इसलिए समस्या को हल करने वाले बाइट्स में सबसे छोटा कोड जीतता है।
code-golf  ascii-art  graphical-output  rubiks-cube 
— betseg
स्रोत
2
— 06
क्या हम क्यूब को फिर से उन्मुख करने के लिए चुन सकते हैं (उदाहरण के लिए, व्हाइट यू, ऑरेंज एफ और ग्रीन आर वाले)?
— प्राइमो
हां, जब तक वे अलग और पहचानने योग्य हैं।
— 12
हम समर्थन की जरूरत है S, E, M, x, y, z, u/ Uw, d/ Dw, r/ Rw, l/ Lw, f/ Fw, b/ Bwसाथ ही चलता रहता है? या केवल डिफ़ॉल्ट: U, D, R, L, F, Bऔर apostrophe के साथ अपने वामावर्त संस्करण ( ')? ऑफ-टॉपिक: मैं हमेशा रूबिक के क्यूब से संबंधित प्रश्नों से आश्चर्यचकित हूं, क्या आप भी एक ट्विस्टी पहेलियाँ कलेक्टर हैं?
— केविन क्रूज़सेन
3
@ केविनक्रूजसेन डांग, यह बहुत सारी पहेलियाँ हैं।
— mbomb007 20

जवाबों:

14

रूबी, 370 339 305 बाइट्स

नवीनतम संपादन: प्लॉटिंग फ़ार्मुलों के पुनर्व्यवस्था और अनावश्यक कोष्ठक को हटाने के द्वारा कुछ बाइट्स बचाए गए। क्यूब की पीढ़ी को फिर से लिखने से एक बड़ी बचत - मुझे कभी नहीं पता था कि रूबी के पास कार्टेशियन उत्पादों के लिए एक बिलिन था!

->s{q=[-66,0,71].product [-87,0,89],[-79,0,82]
s.map{|c|m="LDBRUF".index c[0];e=m/3*2-1
c.sub(/[i']/,"33").chars{q.map{|j|j[m%=3]*e>0&&(j[m-2],j[m-1]=j[m-1]*e,-j[m-2]*e)}}}
t=[" "*12]*9*$/
q.map{|r|a,b,c=r.map{|i|i<=>0}
3.times{|i|r[i]!=0&&t[56+[a*3-a*c-d=b*13,a-d*3+d*c,3-d-c*3+c*a][i]]=r[i].abs.chr}}
t}

अनाम फ़ंक्शन।

स्ट्रिंग्स की एक सरणी को स्वीकार करता है, प्रत्येक एक फेस टर्न का प्रतिनिधित्व करता है (प्रत्येक फेस टर्न के बीच रिक्त स्थान के साथ एक सिंगल स्ट्रिंग एक अतिरिक्त 6 बाइट्स है।)

एक 9x12 आयताकार स्ट्रिंग लौटाता है।

संक्षिप्त विवरण

यह इस प्रश्न के मेरे उत्तर से एक अवधारणा पर आधारित है , जो बदले में जान ड्वोरक द्वारा इसी तरह की अवधारणा पर आधारित था।

पहली पंक्ति 27 क्यूबियों का प्रतिनिधित्व करते हुए, 27 तत्व सरणी उत्पन्न करती है। प्रत्येक क्यूबाई को 3 आयामी वेक्टर द्वारा दर्शाया जाता है जिसमें संकेत अपनी वर्तमान स्थिति का प्रतिनिधित्व करता है और प्रत्येक समन्वय की भयावहता स्टिकर के रंग के लिए एससीआई कोड का प्रतिनिधित्व करती है।

उदाहरण चाल: R के लिए, प्रत्येक घन जांच के लिए यदि x निर्देशांक 0 है और यदि हां तो y और z निर्देशांक को स्वैप करके और उनमें से किसी एक के संकेत को स्वैप करके 90 डिग्री घुमाएं।

9x12 स्थानों की एक सरणी लें और इसमें क्यूब को प्लॉट करें। प्रत्येक क्यूबी और अक्ष के लिए हम जांचते हैं कि क्या स्टिकर मौजूद है (उस अक्ष नोजेरो में समन्वय करें), और बाहर काम करना है जहां उसे जाना है। फिर हम समन्वय लेते .abs.chrहैं और संख्या को आवश्यक चरित्र में बदलने और उसे प्लॉट करने के लिए प्रदर्शन करते हैं।

परीक्षण कार्यक्रम में अपराजित (प्रति 339 बाइट संपादित करें)

f=->s{

  q=(0..26).map{|i|                         #Build an array of 27 cubies
    [[-66,0,71][i%3],                       #x coordinate B.G
     [-87,0,89][i/3%3],                     #y coordinate Y.W
     [-79,0,82][i/9]]                       #z coordinate O.R
  }

  s.map{|c|                                 #For each move in the input array
    m="LDBRUF".index(c[0]);e=m/3*2-1        #m=face to move. e=-1 for LDB, +1 for RUF.
    c.sub(/[i']/,"33").chars{               #Substitute "i" and "'" for "33" so chars in string = clockwise 1/4 turns required. For each char...
      q.map{|j|j[m%=3]*e>0&&                #...and each cubie, m%3 tells the relevant axis. if coordinate*e>1 rotate the cubie 1/4 turn.
        (j[m-2],j[m-1]=j[m-1]*e,-j[m-2]*e)} #Swap other two axes and change sign of one. e performs sign change if necessary for LDB.
    }
  }

  t=[" "*12]*9*$/                           #Make an array of 9 strings of 12 spaces, then make a single string by joining them with newlines
  q.map{|r|                                 #For each cubie
    a,b,c=r.map{|i|i<=>0}                   #make a normalised (-1,0,1) copy of each coordinate.
    d=b*13                                  #13 chars per line, d will be useful for plotting to the correct line of the output.
    3.times{|i|                             #For each of the 3 coordinates of the cubie
      r[i]!=0&&                             #if zero, sticker doesn't exist (edges and centres have <3 stickers.) If not zero plot the sticker. 
      t[[56-d+a*3-a*c,                      #Calculate position on plot for x (L/R faces),
         56-d*3+d*c+a,                      #Calculate position on plot for y (D/U faces),
         59-d-c*3+c*a][i]]=                 #Calculate position on plot for z (B/F faces). Select the correct axis. 
      r[i].abs.chr                          #Convert the coordinate to a character and assign to the correct space on the output plot.
    }
  }
t}                                          #Return the output string.

puts f[gets.chomp.split]

उत्पादन

Checkerboard
U2 D2 F2 B2 L2 R2
   YWY
   WYW
   YWY
BGBRORGBGORO
GBGOROBGBROR
BGBRORGBGORO
   WYW
   YWY
   WYW

6-spot
U D' R L' F B' U D'
   RRR
   RYR
   RRR
WWWGGGYYYBBB
WBWGRGYGYBOB
WWWGGGYYYBBB
   OOO
   OWO
   OOO

Testcase
U2 L' D
   OYY
   RYY
   RYY
GBBWOOBBBRRY
GBBWRRGGGOOY
OOYGBBWRRGGG
   ROO
   WWW
   WWW
— स्तर नदी सेंट
स्रोत
11

जावास्क्रिप्ट (ईएस 5), 1615 बाइट्स

function m(a){b=[];b[0]=a[6];b[2]=a[0];b[8]=a[2];b[6]=a[8];b[1]=a[3];b[5]=a[1];b[7]=a[5];b[3]=a[7];b[4]=a[4];return b}function q(a,b){c=[];c[0]=b[0];c[1]=b[1];c[2]=a[2];c[3]=b[3];c[4]=b[4];c[5]=a[5];c[6]=b[6];c[7]=b[7];c[8]=a[8];return c}function r(a){var b=[];b[0]=m(a[0]);b[1]=q(a[2],a[1]);b[4]=q(a[1],a[4]);b[3]=q(a[4],a[3]);b[2]=q(a[3],a[2]);b[5]=a[5];return b}function x(a){var b=[];b[0]=m(a[0]);b[1]=a[2];b[2]=a[3];b[3]=a[4];b[4]=a[1];b[5]=m(m(m(a[5])));return b}function y(a){var b=[];b[0]=a[4];b[1]=m(a[1]);b[2]=a[0];b[3]=m(m(m(a[3])));b[4]=a[5];b[5]=a[2];return b}function s(a){a=a.replace(/F2/,"F F");a=a.replace(/R2/,"R R");a=a.replace(/U2/,"U U");a=a.replace(/D2/,"D D");a=a.replace(/B2/,"B B");a=a.replace(/L2/,"L L");a=a.replace(/F'/,"F F F");a=a.replace(/R'/,"R R R");a=a.replace(/U'/,"U U U");a=a.replace(/D'/,"D D D");a=a.replace(/B'/,"B B B");a=a.replace(/L'/,"L L L");a=a.replace(/F/,"y y y R y");a=a.replace(/L/,"y y R y y");a=a.replace(/U/,"x y R y y y x x x");a=a.replace(/B/,"y R y y y");a=a.replace(/D/,"x y y y R y x x x");a=a.split(" ");for(b=["RRRRRRRRR".split(""),"WWWWWWWWW".split(""),"GGGGGGGGG".split(""),"YYYYYYYYY".split(""),"BBBBBBBBB".split(""),"OOOOOOOOO".split("")],c=0;c<a.length;++c)"x"==a[c]?b=x(b):"y"==a[c]?b=y(b):"R"==a[c]&&(b=r(b));return p(b)}function p(a){for(var b="",c=0;3>c;++c)b+="\n   "+a[1][3*c+0]+a[1][3*c+1]+a[1][3*c+2];for(c=0;3>c;++c)b+="\n"+a[5][3*c+0]+a[5][3*c+1]+a[5][3*c+2]+a[2][3*c+0]+a[2][3*c+1]+a[2][3*c+2]+a[0][3*c+0]+a[0][3*c+1]+a[0][3*c+2]+a[4][3*c+0]+a[4][3*c+1]+a[4][3*c+2];for(c=0;3>c;++c)b+="\n   "+a[3][3*c+0]+a[3][3*c+1]+a[3][3*c+2];return b}

Ungolfed: 

function m(fac){ //Turn a face
    //0 1 2
    //3 4 5
    //6 7 8

    var fac2=[];
    fac2[0]=fac[6];
    fac2[2]=fac[0];
    fac2[8]=fac[2];
    fac2[6]=fac[8];

    fac2[1]=fac[3];
    fac2[5]=fac[1];
    fac2[7]=fac[5];
    fac2[3]=fac[7];

    fac2[4]=fac[4];

    return fac2;
}

function q(face1,face3){ //Swap right third of two faces
    var face2=[];
    face2[0]=face3[0];
    face2[1]=face3[1];
    face2[2]=face1[2];
    face2[3]=face3[3];
    face2[4]=face3[4];
    face2[5]=face1[5];
    face2[6]=face3[6];
    face2[7]=face3[7];
    face2[8]=face1[8];
    return face2;
}

function r(state){ //Apply a R move
    var state2=[];
    state2[0]=m(state[0]);
    //Swap right set of Front, Up, Back, Down (2,1,4,3);

    state2[1]=q(state[2],state[1]);
    state2[4]=q(state[1],state[4]);
    state2[3]=q(state[4],state[3]);
    state2[2]=q(state[3],state[2]);
    state2[5]=state[5];
    return state2;
}

function x(staten){ //Apply a x move
    var state2=[];
    state2[0]=m(staten[0]);
    state2[1]=staten[2];
    state2[2]=staten[3];
    state2[3]=staten[4];
    state2[4]=staten[1];
    state2[5]=m(m(m(staten[5])));
    return state2;
}

function y(state){ //Apply a y move
    var state2=[];
    state2[0]=state[4];
    state2[1]=m(state[1]);
    state2[2]=state[0];
    state2[3]=m(m(m(state[3])));
    state2[4]=state[5];
    state2[5]=state[2];
    return state2;
}

function s(algo){ //Solve a cube, representing every move with x, y and R
    algo=algo.replace(/F2/,"F F");
    algo=algo.replace(/R2/,"R R");
    algo=algo.replace(/U2/,"U U");
    algo=algo.replace(/D2/,"D D");
    algo=algo.replace(/B2/,"B B");
    algo=algo.replace(/L2/,"L L");

    algo=algo.replace(/F'/,"F F F");
    algo=algo.replace(/R'/,"R R R");
    algo=algo.replace(/U'/,"U U U");
    algo=algo.replace(/D'/,"D D D");
    algo=algo.replace(/B'/,"B B B");
    algo=algo.replace(/L'/,"L L L");

    algo=algo.replace(/F/,"y y y R y");
    algo=algo.replace(/L/,"y y R y y");
    algo=algo.replace(/U/,"x y R y y y x x x");
    algo=algo.replace(/B/,"y R y y y");
    algo=algo.replace(/D/,"x y y y R y x x x");

    algo=algo.split(" ");

    var cstate=[["R","R","R","R","R","R","R","R","R"],["W","W","W","W","W","W","W","W","W"],["G","G","G","G","G","G","G","G","G"],["Y","Y","Y","Y","Y","Y","Y","Y","Y"],["B","B","B","B","B","B","B","B","B"],["O","O","O","O","O","O","O","O","O"]];

    for(var i=0;i<algo.length;++i){
        if(algo[i]=="x"){
            cstate=x(cstate);
        }else if(algo[i]=="y"){
            cstate=y(cstate);
        }else if(algo[i]=="R"){
            cstate=r(cstate);
        }
    }

    return p(cstate);
}

function p(cstate){ //Print
    var out="";
    var leftspace="\n   ";
    for(var i=0;i<3;++i){
        out+=leftspace+cstate[1][3*i+0]+cstate[1][3*i+1]+cstate[1][3*i+2]
    }
    for(var i=0;i<3;++i){
        out+="\n"+cstate[5][3*i+0]+cstate[5][3*i+1]+cstate[5][3*i+2]+cstate[2][3*i+0]+cstate[2][3*i+1]+cstate[2][3*i+2]+cstate[0][3*i+0]+cstate[0][3*i+1]+cstate[0][3*i+2]+cstate[4][3*i+0]+cstate[4][3*i+1]+cstate[4][3*i+2]
    }
    for(var i=0;i<3;++i){
        out+=leftspace+cstate[3][3*i+0]+cstate[3][3*i+1]+cstate[3][3*i+2]
    }
    return out;
}

यह एक बहुत ही कठिन चुनौती थी।

व्याख्या

उदाहरण के लिए कॉल करें s("R U' F") ।

कार्यक्रम केवल x, y और R चालों को निष्पादित कर सकता है।

U'के बराबर है U U U, इसलिए उसे प्रतिस्थापित करें।

Fके बराबर है y y y R y, इसलिए उसे प्रतिस्थापित करें।

R U' F'इसलिए इसके बराबर है R U U U y y y R y, जो प्रोग्राम चला सकता है।

cstate को हल किए गए घन से परिभाषित किया जाता है। एक घन का प्रतिनिधित्व एक सरणी से होता है जिसमें 9 स्टिकर वाले 6 सरणियां होती हैं। पहला सरणी R के लिए, दूसरा U के लिए, तीसरा F, D, B के लिए, अंतिम सरणी L के लिए है। जब y को क्रियान्वित करने की आवश्यकता होती है, तो प्रोग्राम फ्रंट, लेफ्ट, बैक और राइट फेस के चार एरे को स्वैप करता है। एक एक्स के लिए, यह सामने, नीचे, पीछे और ऊपर स्वैप होता है। हर घुमाव अन्य चेहरों को भी घुमाता है, जिन्हें स्वैप नहीं किया गया था। AR मूव राइट फेस को घुमाता है और फ्रंट, राइट, बैक, डाउन फेस के राइट पार्ट को स्वैप करता है।

इसे एक्स, वाई और आर के साथ परिभाषित करके सभी प्रकार की चालों के साथ समस्याओं को हल करने में सक्षम होने के लिए संशोधित किया जा सकता है।

— पॉल शमित्ज़
स्रोत
मैं अपना कॉन्सेप्ट चुराने के लिए केवल 3 चालों पर काम कर रहा हूं ताकि खुद को छोटा बना सकूं?) शानदार आइडिया
— हारून
तो पहले में R U' F2परिवर्तित हो जाता है R U' F F, फिर R U U U F F, फिर R x y R y y y x x x x y R y y y x x x x y R y y y x x x y y y R y y y y R yकिस पर अमल करता है? अजीब .. लेकिन बहुत मूल। +1 :) आप इस विचार के साथ कैसे आए?
— केविन क्रूज़सेन 20
2
मेरा कोड भी U'में कनवर्ट करता U U Uहै, लेकिन xतों और yएस वास्तव में अच्छे हैं। मैं इसे भी चोरी करना चाहता हूं: पी
— बीटसेग
@ केविनक्रूजसेन रोटेशन केवल एक परत को प्रभावित करने वाले कदम की तुलना में कार्यक्रम के लिए बहुत आसान है। मैंने पहले NxN क्यूब्स के अनुकरण के लिए एक कार्यक्रम के साथ इस अवधारणा की कोशिश की, और अब यहां एक आसान संस्करण लागू किया। यह पहली बार किसी भी निकाल देता है 'और 2, और फिर सभी चालों बदल देता है।
— पॉल शमित्ज़
अच्छी तरह से किया लेकिन अभी भी गोल्फ है। मैं इसे ES6
— edc65
11

सी, 1715 1709 1686 1336 1328 बाइट्स

25 बाइट्स ने @KevinCruijssen को धन्यवाद दिया!

अब तक कोई जवाब नहीं, इसलिए मैंने अपना समाधान खुद करने का फैसला किया।

#define m(a,b,c,d)t[c][d]=r[a][b]; 
#define n(a)m(a,0,a,2)m(a,1,a,5)m(a,2,a,8)m(a,3,a,1)m(a,5,a,7)m(a,6,a,0)m(a,7,a,3)m(a,8,a,6)
#define y memcpy
typedef char R[6][9];R t;F(R r){y(t,r,54);n(0)m(4,6,1,0)m(4,7,1,3)m(4,8,1,6)m(1,0,5,0)m(1,3,5,1)m(1,6,5,2)m(5,0,3,2)m(5,1,3,5)m(5,2,3,8)m(3,2,4,6)m(3,5,4,7)m(3,8,4,8)y(r,t,54);}B(R r){y(t,r,54);n(2)m(1,2,4,0)m(1,5,4,1)m(1,8,4,2)m(3,0,5,6)m(3,3,5,7)m(3,6,5,8)m(4,0,3,6)m(4,1,3,3)m(4,2,3,0)m(5,6,1,8)m(5,7,1,5)m(5,8,1,2)y(r,t,54);}L(R r){y(t,r,54);n(3)m(0,0,5,0)m(0,3,5,3)m(0,6,5,6)m(2,2,4,6)m(2,5,4,3)m(2,8,4,0)m(4,0,0,0)m(4,3,0,3)m(4,6,0,6)m(5,0,2,8)m(5,3,2,5)m(5,6,2,2)y(r,t,54);}E(R r){y(t,r,54);n(1)m(0,2,4,2)m(0,5,4,5)m(0,8,4,8)m(5,2,0,2)m(5,5,0,5)m(5,8,0,8)m(4,2,2,6)m(4,5,2,3)m(4,8,2,0)m(2,0,5,8)m(2,3,5,5)m(2,6,5,2)y(r,t,54);}U(R r){y(t,r,54);n(4)m(0,0,3,0)m(0,1,3,1)m(0,2,3,2)m(1,0,0,0)m(1,1,0,1)m(1,2,0,2)m(2,0,1,0)m(2,1,1,1)m(2,2,1,2)m(3,0,2,0)m(3,1,2,1)m(3,2,2,2)y(r,t,54);}D(R r){y(t,r,54);n(5)m(0,6,1,6)m(0,7,1,7)m(0,8,1,8)m(1,6,2,6)m(1,7,2,7)m(1,8,2,8)m(2,6,3,6)m(2,7,3,7)m(2,8,3,8)m(3,6,0,6)m(3,7,0,7)m(3,8,0,8)y(r,t,54);}a,b,c,d,e,o,p,l;f(char*z,R s){char c[6]="RGOBYW";for(;b<7;b++)for(a=0;a<10;)s[b][a++]=c[b];for(l=strlen(z);l-->0;){d=*z++;if(d-32){e=*z++;if(*z++-32)*z++;o=e-50?e-39?1:3:2;for(p=0;p++<o;)d-70?d-66?d-76?d-82?d-85?D(s):U(s):E(s):L(s):B(s):F(s);}}}

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

पुराना संस्करण:

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <ctype.h>

typedef char Tile;
typedef Tile Face[10];
typedef Face Rubik[7];

void main_loop(Rubik);
void rubik_init(Rubik);
void rubik_print(Rubik);
void rotate(Rubik, char, char);
void print_tile(Rubik, int, int);

void F(Rubik);
void B(Rubik);
void L(Rubik);
void R(Rubik);
void U(Rubik);
void D(Rubik);

#define move(a, b, c, d) \
      temp[c][d] = rubik[a][b]

#define move_f(a) \
    move(a, 1, a, 3); \
    move(a, 2, a, 6); \
    move(a, 3, a, 9); \
    move(a, 4, a, 2); \
    move(a, 6, a, 8); \
    move(a, 7, a, 1); \
    move(a, 8, a, 4); \
    move(a, 9, a, 7)

void F(Rubik rubik) {
    Rubik temp;
    memcpy(temp, rubik, sizeof(Rubik));
    move_f(1);
    move(5, 7, 2, 1);
    move(5, 8, 2, 4);
    move(5, 9, 2, 7);
    move(2, 1, 6, 1);
    move(2, 4, 6, 2);
    move(2, 7, 6, 3);
    move(6, 1, 4, 3);
    move(6, 2, 4, 6);
    move(6, 3, 4, 9);
    move(4, 3, 5, 7);
    move(4, 6, 5, 8);
    move(4, 9, 5, 9);
    memcpy(rubik, temp, sizeof(Rubik));
}

void B(Rubik rubik) {
    Rubik temp;
    memcpy(temp, rubik, sizeof(Rubik));
    move_f(3);
    move(2, 3, 5, 1);
    move(2, 6, 5, 2);
    move(2, 9, 5, 3);
    move(4, 1, 6, 7);
    move(4, 4, 6, 8);
    move(4, 7, 6, 9);
    move(5, 1, 4, 7);
    move(5, 2, 4, 4);
    move(5, 3, 4, 1);
    move(6, 7, 2, 9);
    move(6, 8, 2, 6);
    move(6, 9, 2, 3);
    memcpy(rubik, temp, sizeof(Rubik));
}

void L(Rubik rubik) {
    Rubik temp;
    memcpy(temp, rubik, sizeof(Rubik));
    move_f(4);
    move(1, 1, 6, 1);
    move(1, 4, 6, 4);
    move(1, 7, 6, 7);
    move(3, 3, 5, 7);
    move(3, 6, 5, 4);
    move(3, 9, 5, 1);
    move(5, 1, 1, 1);
    move(5, 4, 1, 4);
    move(5, 7, 1, 7);
    move(6, 1, 3, 9);
    move(6, 4, 3, 6);
    move(6, 7, 3, 3);
    memcpy(rubik, temp, sizeof(Rubik));
}

void R(Rubik rubik) {
    Rubik temp;
    memcpy(temp, rubik, sizeof(Rubik));
    move_f(2);
    move(1, 3, 5, 3);
    move(1, 6, 5, 6);
    move(1, 9, 5, 9);
    move(6, 3, 1, 3);
    move(6, 6, 1, 6);
    move(6, 9, 1, 9);
    move(5, 3, 3, 7);
    move(5, 6, 3, 4);
    move(5, 9, 3, 1);
    move(3, 1, 6, 9);
    move(3, 4, 6, 6);
    move(3, 7, 6, 3);
    memcpy(rubik, temp, sizeof(Rubik));
}

void U(Rubik rubik) {
    Rubik temp;
    memcpy(temp, rubik, sizeof(Rubik));
    move_f(5);
    move(1, 1, 4, 1);
    move(1, 2, 4, 2);
    move(1, 3, 4, 3);
    move(2, 1, 1, 1);
    move(2, 2, 1, 2);
    move(2, 3, 1, 3);
    move(3, 1, 2, 1);
    move(3, 2, 2, 2);
    move(3, 3, 2, 3);
    move(4, 1, 3, 1);
    move(4, 2, 3, 2);
    move(4, 3, 3, 3);
    memcpy(rubik, temp, sizeof(Rubik));
}

void D(Rubik rubik) {
    Rubik temp;
    memcpy(temp, rubik, sizeof(Rubik));
    move_f(6);
    move(1, 7, 2, 7);
    move(1, 8, 2, 8);
    move(1, 9, 2, 9);
    move(2, 7, 3, 7);
    move(2, 8, 3, 8);
    move(2, 9, 3, 9);
    move(3, 7, 4, 7);
    move(3, 8, 4, 8);
    move(3, 9, 4, 9);
    move(4, 7, 1, 7);
    move(4, 8, 1, 8);
    move(4, 9, 1, 9);
    memcpy(rubik, temp, sizeof(Rubik));
}

int main(int argc, char *argv[]) {
    Rubik rubik;
    rubik_init(rubik);
    main_loop(rubik);
    return 0;
}

void main_loop(Rubik rubik) {
    char a, b;
    for (;;) {
        a=toupper(getchar());
        if (a == 'Q') break;
        if (a != 10) {
            b=toupper(getchar());
            if (b != 10) getchar();
            rotate(rubik, a, b);
        }
        rubik_print(rubik);
    }
}

void rubik_init(Rubik rubik) {
    int i,n;
    char c[7] = " RGOBYW";

    for (n=1; n<=7; n++)
        for (i=1; i<=10; i++)
            rubik[n][i] = c[n];
}

void rotate(Rubik rubik, char a, char b){
    int i = b == '2' ? 2 : b == '\'' || b == toupper('i') ? 3 : 1;
    int j;
    for (j=0; j<i; j++)
        if (a == 'F') F(rubik);
        else if (a == 'B') B(rubik);
        else if (a == 'L') L(rubik);
        else if (a == 'R') R(rubik);
        else if (a == 'U') U(rubik);
        else if (a == 'D') D(rubik);
        else;
}

void rubik_print(Rubik rubik) {
    int i,j,k;

    for (i=1; i<=9; i++)
        if (i%3==0) {
            print_tile(rubik,5,i);
            printf("\n");
        }
        else if (i%3==1) {
            printf("    ");
            print_tile(rubik,5,i);
        }
        else
            print_tile(rubik,5,i);

    printf("\n");

    for (k=1; k<=3; k++) {
        for (i=3; i<=6; i++) {
            for (j=k*3-2; j<=k*3; j++)
                print_tile(rubik, i%4+1, j);
            printf(" ");
        }
        printf("\n");
    }

    printf("\n");

    for (i=1; i<=9; i++)
        if (i%3==0) {
            print_tile(rubik, 6, i);
            printf("\n");
        }
        else if (i%3==1) {
            printf("    ");
            print_tile(rubik, 6, i);
        }
        else
            print_tile(rubik, 6, i);

}

void print_tile(Rubik rubik, int a, int b) {
    switch (rubik[a][b]) {
      case 'R':
        printf("R");
        break;
      case 'O':
        printf("O");
        break;
      case 'B':
        printf("B");
        break;
      case 'G':
        printf("G");
        break;
      case 'Y':
        printf("Y");
        break;
      case 'W':
        printf("W");
        break;
      default:
        exit(1);
    }
}
— betseg
स्रोत
4
मैं कोई सी-प्रोग्रामर नहीं हूं, इसलिए अगर मैं गलत हूं तो मुझे सुधारें, लेकिन मेरा मानना ​​है कि आप अपने कुछ लूप्स को गोल्फ के लिए कर सकते हैं: for(b=1;b<8;b++)for(a=1;a<11;a++)r[b][a]=c[b];टू for(b=1;b<8;)for(a=1;a<11;)r[b][a++]=c[b++];एंड for(i=1;i<=9;i++)टू for(i=0;++i<=9;), और कुछ अन्य फॉर-लूप्स भी। इसके अलावा, else ifबस करने के लिए बदला जा सकता है ifकि आपके द्वारा चेक if(d==66)B(r);if(d==76)L(r);...और, जब तक कि iनकारात्मक हो सकता है, आप बदल सकते हैं if(i%3==0)करने के लिए if(i%3<1)दो बार। और मुझे यकीन है कि यह कुछ और हो सकता है। अपनी चुनौती पर जवाब देखकर अच्छा लगा, हालाँकि। :)
— केविन क्रूज़सेन 14
मैंने छोरों को गोल करने की कोशिश की, लेकिन यह काम नहीं किया, इसलिए मैंने उन्हें छूने का फैसला किया। मैं बाहर हूं और अब उन्हें कोशिश नहीं कर सकता। लेकिन आप ifएस के बारे में सही हैं और iयद्यपि, मैंने घर जाने के बाद उन्हें संपादित किया। धन्यवाद!
— betseg
@ केविनक्रूजसेन ने elseएस बोर्क प्रोग्राम को हटा दिया , गोल्फिंग लूप्स बोर्क प्रोग्राम, काम के साथ चीज i। फिर भी धन्यवाद।
— 19
हम्म, क्यों else ifबदलती है ifअसफल? : S else ifआपके द्वारा तुलना किए जाने वाले प्रत्येक में d==##, इसलिए मैं उलझन में हूं कि यह क्यों नहीं है। फिर से, मैं सी प्रोग्राम नहीं करता, इसलिए शायद मुझे कुछ स्पष्ट याद आ रहा है कि सी नहीं कर सकता, लेकिन फिर भी .. आह ठीक है, खुशी है कि मैं <1इसके बजाय modulo के साथ मदद कर सकता था==0
— केविन क्रूज़सेन
1
— सीलिंगकैट
9

पायथन 3,  610 563 533  526 बाइट्स

-7 बाइट्स मेरे सहकर्मी rhsmits के लिए धन्यवाद (वास्तव d,*cमें निरर्थक कोष्ठक का अच्छा रूप और हटाने)

यह एक पूर्ण कार्यक्रम है।

import re
d,*c=[f*9for f in' YBRGOW']
r=lambda f:[f[int(v)]for v in'630741852']
U=lambda c:[r(c[0])]+[c[j%4+1][:3]+c[j][3:]for j in(1,2,3,4)]+[c[5]]
y=lambda c:[r(c[0])]+c[2:5]+[c[1],r(r(r(c[5])))]
z=lambda c:[c[2],r(r(r(c[1]))),c[5],r(c[3]),c[0][::-1],c[4][::-1]]
exec("c="+"(c);c=".join("".join("zzzUz U zzUzz yyyzUzzzy zUzzz yzUzzzyyy".split()[ord(t)%11%7]*(ord(n or'a')%6)for t,n in re.findall("([B-U])(['2i]?)",input())))+"(c)")
k=' '.join
for q in[d,c[0]],c[1:5],[d,c[5]]:
 for w in 0,3,6:print(k(k(f[w:w+3])for f in q))

सुपरफ्लिप और सभी परीक्षण आइडोन पर उपलब्ध हैं या इसे ऑनलाइन आज़माएं!

कार्यक्रम:

  • YBRGOWस्टिकर के छह चेहरे बनाता है ।
  • एक फ़ंक्शन बनाता है r, जो केवल चेहरे पर स्टिकर घुमाता है, दक्षिणावर्त एक चौथाई-मोड़
  • एक समारोह, बनाता है U, जो घूमता Uचेहरा दक्षिणावर्त लगाने से एक चौथाई मोड़ rके शीर्ष बैंड पर और स्टिकर घूर्णन LFRBदक्षिणावर्त एक चौथाई बारी
  • एक समारोह, बनाता है y, जो प्रदर्शन rपर Uऔर Dचेहरे और स्लाइस LFRB
    इस प्रदर्शन में पूर्ण घन के एक रोटेशन - yअक्ष (जिसके माध्यम से चलाता है Uऔर D)
    - रोटेशन दक्षिणावर्त है ऊपर से देख अगर
  • एक फ़ंक्शन बनाता है z, जो zअक्ष में पूरे क्यूब के रोटेशन को दक्षिणावर्त एक चौथाई मोड़ पर Rदेखता है (अक्ष के माध्यम से चलता है Rऔर L) - इस बार क्योंकि चेहरे हमारे नेट में उन्मुख हैं (उसी तरह ओपी में दिए गए हैं) को पलटना पड़ता है Bऔर Uचेहरे पर (वे क्षैतिज से ऊर्ध्वाधर भागों तक स्विच करते हैं और इसके विपरीत)
  • इनपुट पर एक रेगेक्स करता है input(), (किए जाने वाले मूव्स) एक चरित्र से मेल खाता है BUDLRF(वास्तव में B-U) संभवतः एक चरित्र द्वारा पीछा किया जाता है'i2
  • क्लॉकवाइज़ 'i2टर्न की संख्या से एक मैपिंग करता है (इन मॉड के ऑर्डिनल्स 6काम करते हैं, डमी के साथ aउपज के लिए 1जब कोई भी मौजूद नहीं है)
  • कॉल करने के लिए इन सिंगल क्लॉकवाइज़ टर्न निर्देशों में से प्रत्येक को मैप करने के लिए एक लुकअप करता है yऔर z, U(जो अब फेस का निर्देश होगा) का एक क्वार्टर-टर्न होता है , और फिर कॉल किए गए सेटअप के अनुक्रम को उलटा करने के लिए कॉल करता है। 11तब तक 7नक्शे द्वारा चेहरे के चरित्र के माप के क्रम को लेते हुए B:0 U:1 D:2 L:3 F:4 R:5, एक साधारण अनुक्रमण को रिक्त स्थान से विभाजित फ़ंक्शन नाम अनुक्रमों की एक स्ट्रिंग में अनुमति देता है।
  • वास्तव में युद्धाभ्यास करने के लिए स्ट्रिंग निष्पादित करता है
  • dमुद्रण को छोटा करने के लिए एक डमी चेहरा बनाता है
  • पंक्ति में (सहित में से प्रत्येक के लिए छोड़ दिया करने के लिए नेट में पंक्तियों और चेहरे के माध्यम से कदम एक डमी चेहरे से परिणाम प्रिंट UऔरD

यहाँ सुपरफ्लिप है :

D:\Python Scripts>python rubiksAscii.py
U R2 F B R B2 R U2 L B2 R U' D' R2 F R' L B2 U2 F2
      Y O Y
      B Y G
      Y R Y
B Y B R Y R G Y G O Y O
O B R B R G R G O G O B
B W B R W R G W G O W O
      W R W
      B W G
      W O W
— जोनाथन एलन
स्रोत
8

अजगर 760 750 649 बाइट्स

बेशर्मी से @Paul Schmitz: D से केवल 3 घुमाव का उपयोग करने का विचार चुरा लिया

नया संस्करण:

from numpy import*
c=kron([[32,89,32,32],[66,82,71,79],[32,87,32,32]],ones([3,3])).astype(int)
def x():t=copy(c);c[:3,3:6],c[3:6,3:6],c[6:,3:6],c[3:6,9:],c[3:6,:3],c[3:6,6:9]=t[3:6,3:6],t[6:,3:6],rot90(t[3:6,9:],2),rot90(t[:3,3:6],2),rot90(t[3:6,:3]),rot90(t[3:6,6:9],3)
def y():c[3:6],c[:3,3:6],c[6:,3:6]=roll(c[3:6],3,1),rot90(c[:3,3:6]),rot90(c[6:,3:6],3)
def F():c[2:7,2:7]=rot90(c[2:7,2:7],3)
s=raw_input()
for p in"':i,Fi:FFF,F2:FF,Bi:BBB,B2:BB,Ri:RRR,R2:RR,Li:LLL,L2:LL,Ui:UUU,U2:UU,Di:DDD,D2:DD,B:xxFxx,R:yyyFy,L:yFyyy,U:xxxFx,D:xFxxx".split(','):s=s.replace(*p.split(':'))
for S in s:eval(S+'()')
for r in c:print(''.join(chr(x)for x in r))

मैं ज्यादातर सिर्फ बहुत सारी सुन्न सूची का काम करता था और इसका निर्माण रोटेट और रोल कार्यों में करता था। इनपुट को सीधे फ़ंक्शन को कॉल करके नियंत्रित किया जाता हैeval()

from numpy import*
l=[0];c=kron([[32,89,32,32],[66,82,71,79],[32,87,32,32]],ones([3,3])).astype(int)
def i():l[0]();l[0]()
def d():l[0]()
def U():c[:3,3:6]=rot90(c[:3,3:6],3);c[3]=roll(c[3],9);l[0]=U
def D():c[6:,3:6]=rot90(c[6:,3:6],3);c[5]=roll(c[5],3);l[0]=D
def F():c[2:7,2:7]=rot90(c[2:7,2:7],3);l[0]=F
def B():c[3:6,9:]=rot90(c[3:6,9:],3);t=copy(c);c[:,:9],c[1:-1,1:8]=rot90(t[:,:9]),t[1:-1,1:8];l[0]=B
def R():c[3:6,6:9]=rot90(c[3:6,6:9],3);t=copy(c);c[:6,5],c[3:6,9],c[6:,5]=t[3:,5],t[2::-1,5],t[5:2:-1,9];l[0]=R
def L():c[3:6,:3]=rot90(c[3:6,:3],3);t=copy(c);c[3:,3],c[3:6,-1],c[:3,3]=t[:6,3],t[:5:-1,3],t[5:2:-1,-1];l[0]=L
for s in raw_input().replace("'",'i').replace('2','d').replace(' ',''):eval(s+'()')
for r in c:print(''.join(chr(x)for x in r))

ungolfed ..

import numpy as np
last = [0] #store last move to repeat for inverse or double
           #list is shorter syntax than global var

cube = np.array([
[' ',' ',' ','Y','Y','Y',' ',' ',' ',' ',' ',' '],
[' ',' ',' ','Y','Y','Y',' ',' ',' ',' ',' ',' '],
[' ',' ',' ','Y','Y','Y',' ',' ',' ',' ',' ',' '],
['B','B','B','R','R','R','G','G','G','O','O','O'],
['B','B','B','R','R','R','G','G','G','O','O','O'],
['B','B','B','R','R','R','G','G','G','O','O','O'],
[' ',' ',' ','W','W','W',' ',' ',' ',' ',' ',' '],
[' ',' ',' ','W','W','W',' ',' ',' ',' ',' ',' '],
[' ',' ',' ','W','W','W',' ',' ',' ',' ',' ',' ']
]) #ascii ascii codes in golfed version

def i(): #triple move (inverse)
    last[0]()
    last[0]()

def d(): #double move
    last[0]()

def U(): #clockwise upface (yellow)
    cube[:3,3:6] = np.rot90(cube[:3,3:6],3)
    cube[3] = np.roll(cube[3],9)
    last[0] = U

def D(): #clockwise downface (white)
    cube[6:,3:6] = np.rot90(cube[6:,3:6],3)
    cube[5] = np.roll(cube[5],3)
    last[0] = D

def F(): #clockwise frontface (red)
    cube[2:7,2:7] = np.rot90(cube[2:7,2:7],3)
    last[0] = F

def B(): #clockwise backface (orange)
    cube[3:6,9:] = np.rot90(cube[3:6,9:],3)
    tempCube = np.copy(cube)
    cube[:,:9],cube[1:-1,1:8] = np.rot90(tempCube[:,:9]),tempCube[1:-1,1:8]
    last[0] = B

def R(): #clockwise rightface (green)
    cube[3:6,6:9] = np.rot90(cube[3:6,6:9],3)
    tempCube = np.copy(cube)
    cube[:6,5],cube[3:6,9],cube[6:,5] = tempCube[3:,5],tempCube[2::-1,5],tempCube[5:2:-1,9]
    last[0] = R

def L(): #clockwise leftface (blue)
    cube[3:6,:3] = np.rot90(cube[3:6,:3],3)
    tempCube = np.copy(cube)
    cube[3:,3],cube[3:6,-1],cube[:3,3] = tempCube[:6,3],tempCube[:5:-1,3],tempCube[5:2:-1,-1]
    last[0] = L


for character in raw_input('type a move sequence: ').replace("'",'i').replace('2','d').replace(' ',''):
    eval(character+'()')

print("-"*12)

for row in cube:
    print(''.join(character for character in row)) #uses ascii codes in golfed version

परीक्षण इनपुट: 

>>> runfile('C:~/rubiks cube.py', wdir='C:~/python/golf')
U2 L' D
   OYY      
   RYY      
   RYY      
GBBWOOBBBRRY
GBBWRRGGGOOY
OOYGBBWRRGGG
   ROO      
   WWW      
   WWW

टिप्पणियाँ या सुझाव बहुत सराहना की है :)

— हारून
स्रोत
2
of using only 3 rotationsगलत। कार्यक्रम किसी भी क्रम को अधिक चाल के साथ अनुक्रम में परिवर्तित करता है। यदि आप इनपुट करते हैं F F F F, तो यह 3 से अधिक घुमाव का उपयोग करता है, क्योंकि यह धर्मान्तरित होता है y y y R y y y y R y y y y R y y y y R y। इसमें तीन प्रकार के घुमावों का उपयोग किया जाता है।
— पॉल शमित्ज़
@PaulSchmitz तीन प्रकार का मेरा मतलब है .... रूपांतरण को सातवीं पंक्ति में स्ट्रिंग में सूचीबद्ध किया गया है
— आरोन
7

सी, 839 बाइट्स

#include <stdio.h>
#define b(c) c,c+1,c+2,c+15,c+28,c+27,c+26,c+13
char a[]="   YYY      \n   YYY      \n   YYY      \nBBBRRRGGGOOO\nBBBRRRGGGOOO\nBBBRRRGGGOOO\n   WWW      \n   WWW      \n   WWW      \n",k;int d[][8]={b(3),b(39),b(42),b(45),b(48),b(81)},e[][12]={50,49,48,47,46,45,44,43,42,41,40,39,3,16,29,42,55,68,81,94,107,76,63,50,29,30,31,45,58,71,83,82,81,67,54,41,109,96,83,70,57,44,31,18,5,48,61,74,39,52,65,107,108,109,73,60,47,5,4,3,65,66,67,68,69,70,71,72,73,74,75,76},i,*j,r,p,q,s;f(int*g,int h){i=h<0?-1:1;for(j=g;j!=g+h;j+=i){k=a[j[3*h]];for(r=3;r--;)a[j[r*h+h]]=a[j[r*h]];a[*j]=k;}}l(int g,int m){f(d[g+m]-m,m?-2:2);f(e[g+m]-m,m?-3:3);}void n(char*o){while(*o){*o-'U'||(p=0);*o-'L'||(p=1);*o-'F'||(p=2);*o-'R'||(p=3);*o-'B'||(p=4);*o-'D'||(p=5);s=*++o=='\''||*o=='i';q=*o=='2';(s||q)&&o++;l(p,s);q&&l(p,0);}printf("%s",a);}

चूंकि यह एक पूर्ण कार्यक्रम नहीं है (स्ट्रिंग तर्क और इनपुट से कंसोल के साथ फ़ंक्शन), आपको इसे इस तरह से कॉल करने की आवश्यकता है:

int main() {
//  n("U2D2R2L2F2B2");    //checker cube
    n("UDiRL'FBiUD'");    //spotted cube
}

एक समय में केवल एक कॉल का उपयोग करें क्योंकि फ़ंक्शन वैश्विक चर का उपयोग करता है और संशोधित करता है।

Ungolfed:

#include <stdio.h>

char cube[] = "   YYY      \n"
              "   YYY      \n"
              "   YYY      \n"
              "BBBRRRGGGOOO\n"
              "BBBRRRGGGOOO\n"
              "BBBRRRGGGOOO\n"
              "   WWW      \n"
              "   WWW      \n"
              "   WWW      \n";

#define faceMove(offset) offset,offset+1,offset+2,offset+15,offset+28,offset+27,offset+26,offset+13
int faceMoves[6][8] = {
    faceMove(3),    //Up
    faceMove(39),   //Left
    faceMove(42),   //Front
    faceMove(45),   //Right
    faceMove(48),   //Back
    faceMove(81)    //Down
}, lineMoves[6][12] = {
    50,49,48,47,46,45,44,43,42,41,40,39,    //Up
    3,16,29,42,55,68,81,94,107,76,63,50,    //Left
    29,30,31,45,58,71,83,82,81,67,54,41,    //Front
    109,96,83,70,57,44,31,18,5,48,61,74,    //Right
    39,52,65,107,108,109,73,60,47,5,4,3,    //Back
    65,66,67,68,69,70,71,72,73,74,75,76 //Down
};

int rotate(int*move,int rotation){
    int sign=rotation<0?-1:1;
    for(int*submove=move;submove!=move+rotation;submove+=sign){
        char takeout=cube[submove[3*rotation]];
        for(int j=3;j--;)cube[submove[j*rotation+rotation]]=cube[submove[j*rotation]];
        cube[*submove]=takeout;
    }
}

int move(int move,int inverted){
    rotate(faceMoves[move+inverted]-inverted,inverted?-2:2);
    rotate(lineMoves[move+inverted]-inverted,inverted?-3:3);
}

void performMoves(char*instructions){
    while(*instructions){
        int moveIndex;
        *instructions-'U'||(moveIndex=0);
        *instructions-'L'||(moveIndex=1);
        *instructions-'F'||(moveIndex=2);
        *instructions-'R'||(moveIndex=3);
        *instructions-'B'||(moveIndex=4);
        *instructions-'D'||(moveIndex=5);
        int inverted=*++instructions=='\''||*instructions=='i', twice=*instructions=='2';
        (inverted||twice)&&instructions++;
        move(moveIndex,inverted);
        twice&&move(moveIndex,0);
    }
    printf("%s",cube);
}

int main() {
//  performMoves("U2D2R2L2F2B2");    //checker cube
    performMoves("UDiRL'FBiUD'");    //spotted cube
}

जैसा कि आप देख सकते हैं, मुख्य विचार पूरी तरह से डेटा-संचालित दृष्टिकोण का उपयोग करना है: विभिन्न घुमावों को सूचकांकों की सूची के रूप में व्यक्त किया जाता है जिन्हें अनुमति दी जानी है। इस प्रकार क्रमचय कोड बहुत छोटा और सामान्य हो सकता है।

— cmaster
स्रोत
2
PPCG में आपका स्वागत है! अच्छी पहली पोस्ट!
— R
आप अधिक बाइट्स बचाने के लिए निम्न कार्य कर सकते हैं: f(h,g)int*g;{-2, l(g,m){-8, n(char*o){-5, printf("%s",a)टू puts(a)-7, साथ ही आप चार स्थिरांक को अपने ASCII दशमलव प्रतिनिधित्व -1 से बदल सकते हैं
— खालिद.के
— छत
5

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

¶■

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

स्पष्टीकरण:

¶   read a line from stdin, evaluate
 ■  print the cube to stdout

यदि बाहरी उत्पादन की अनुमति है, तो यह एक विकल्प है। 1 बाइट:

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

STDERRजब प्रोग्राम समाप्त होता है तब अपने मेमोरी क्यूब को क्यूबिकली स्वचालित रूप से डंप करता है। हालाँकि, यह नोटपैड को पहले से प्रिंट करता है।

— एमडी एक्सएफ
स्रोत
2
मैं नहीं जानता कि आप की सराहना या उबाल करना है या नहीं। +1
— जो राजा
@ जॉकिंग दोनों। ठीक उसी तरह जब क्यूबिकली अन्य क्यूब चुनौतियों का सामना करता है। 1 2 3
— एमडी एक्सएफ
4

जावास्क्रिप्ट (ईएस 6), 820

@Paul Schmitz द्वारा छोटी गाड़ी के उत्तर का एक पोर्टिंग। यह अभी भी पूरी तरह से गोल्फ नहीं है, लेकिन इसमें जोड़ा गया मूल्य है जो यह काम करता है।

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

(a,M=a=>[a[6],a[3],a[0],a[7],a[4],a[1],a[8],a[5],a[2]],Q=(a,b)=>[b[0],b[1],a[2],b[3],b[4],a[5],b[6],b[7],a[8]],N=(a,b)=>[b[0],b[1],a[6],b[3],b[4],a[3],b[6],b[7],a[0]],O=(a,b)=>[b[8],a[1],a[2],b[5],a[4],a[5],b[2],a[7],a[8]],R=a=>[M(a[0]),Q(a[2],a[1]),Q(a[3],a[2]),N(a[4],a[3]),O(a[4],a[1]),a[5]],X=a=>[M(a[0]),a[2],a[3],M(M(a[4])),M(M(a[1])),M(M(M(a[5])))],Y=a=>[a[4],M(a[1]),a[0],M(M(M(a[3]))),a[5],a[2]],F=c=>Array(9).fill(c[0]),r='replace',b=[F`G`,F`Y`,F`R`,F`W`,F`O`,F`B`],J=(p,l)=>p.join``[r](/.../g,l))=>(a[r](/(.)2/g,"$1$1")[r](/(.)['i]/g,"$1$1$1")[r](/F/g,"yyyRy")[r](/L/g,"yyRyy")[r](/B/g,"yRyyy")[r](/U/g,"xyRyyyxxx")[r](/D/g,"xyyyRyxxx")[r](/\w/g,c=>b=(c<'a'?R:c<'y'?X:Y)(b)),o=J(b[1],`
   $&`),J(b[5],(c,p)=>o+=`
`+c+b[2].join``.substr(p,3)+b[0].join``.substr(p,3)+b[4].join``.substr(p,3)),o+J(b[3],`
   $&`))

अधिक पठनीय शायद

( 
  a, 
  // local variables as default parameters
  r='replace',
  F=c=>Array(9).fill(c[0]), // function to fill a 3x3 square
  b=[F`G`,F`Y`,F`R`,F`W`,F`O`,F`B`], // cube status
  // aux functions to perform basic moves
  M=a=>[a[6],a[3],a[0],a[7],a[4],a[1],a[8],a[5],a[2]],
  Q=(a,b)=>[b[0],b[1],a[2],b[3],b[4],a[5],b[6],b[7],a[8]],
  N=(a,b)=>[b[0],b[1],a[6],b[3],b[4],a[3],b[6],b[7],a[0]],
  O=(a,b)=>[b[8],a[1],a[2],b[5],a[4],a[5],b[2],a[7],a[8]],
  // R : right side rotation
  R=a=>[M(a[0]),Q(a[2],a[1]),Q(a[3],a[2]),N(a[4],a[3]),O(a[4],a[1]),a[5]],
  // X,Y: to put other sides in place of right side
  X=a=>[M(a[0]),a[2],a[3],M(M(a[4])),M(M(a[1])),M(M(M(a[5])))],
  Y=a=>[a[4],M(a[1]),a[0],M(M(M(a[3]))),a[5],a[2]],
  // aux function for output
  J=(p,l)=>p.join``[r](/.../g,l),
) => (
  // convert common moves to basic moves
  a[r](/(.)2/g,"$1$1")[r](/(.)['i]/g,"$1$1$1")[r](/F/g,"yyyRy")[r](/L/g,"yyRyy")[r](/B/g,"yRyyy")[r](/U/g,"xyRyyyxxx")[r](/D/g,"xyyyRyxxx")
  // then execute each
  [r](/\w/g,c=>b=c<'a'?R(b):c<'y'?X(b):Y(b)),
  // built output in o
  o=J(b[1],'\n   $&'),
  J(b[5],(c,p)=>o+='\n'+c+b[2].join``.substr(p,3)+b[0].join``.substr(p,3)+b[4].join``.substr(p,3)),
  o+J(b[3],'\n   $&') // returned output
)

S=
(a,M=a=>[a[6],a[3],a[0],a[7],a[4],a[1],a[8],a[5],a[2]],Q=(a,b)=>[b[0],b[1],a[2],b[3],b[4],a[5],b[6],b[7],a[8]],N=(a,b)=>[b[0],b[1],a[6],b[3],b[4],a[3],b[6],b[7],a[0]],O=(a,b)=>[b[8],a[1],a[2],b[5],a[4],a[5],b[2],a[7],a[8]],R=a=>[M(a[0]),Q(a[2],a[1]),Q(a[3],a[2]),N(a[4],a[3]),O(a[4],a[1]),a[5]],X=a=>[M(a[0]),a[2],a[3],M(M(a[4])),M(M(a[1])),M(M(M(a[5])))],Y=a=>[a[4],M(a[1]),a[0],M(M(M(a[3]))),a[5],a[2]],F=c=>Array(9).fill(c[0]),r='replace',b=[F`G`,F`Y`,F`R`,F`W`,F`O`,F`B`],J=(p,l)=>p.join``[r](/.../g,l))=>(a[r](/(.)2/g,"$1$1")[r](/(.)['i]/g,"$1$1$1")[r](/F/g,"yyyRy")[r](/L/g,"yyRyy")[r](/B/g,"yRyyy")[r](/U/g,"xyRyyyxxx")[r](/D/g,"xyyyRyxxx")[r](/\w/g,c=>b=(c<'a'?R:c<'y'?X:Y)(b)),o=J(b[1],`
   $&`),J(b[5],(c,p)=>o+=`
`+c+b[2].join``.substr(p,3)+b[0].join``.substr(p,3)+b[4].join``.substr(p,3)),o+J(b[3],`
   $&`))

function update() { O.textContent=S(I.value) }

update()
<input id=I value='U2 Li D' oninput='update()'><pre id=O></pre>
स्निपेट का विस्तार करें

— edc65
स्रोत
मुझे update()स्निपेट चलाते समय मेरे कंसोल में परिभाषित नहीं किया गया है
— कृति लिथोस
ESK अनुरूप ब्राउज़र नहीं होने के लिए @KritiiLithos आपके पास संभवतः एक सिंटैक्स त्रुटि है। मैंने इसे फ़ायरफ़ॉक्स के साथ परीक्षण किया, आप किस ब्राउज़र का उपयोग कर रहे हैं?
— edc65
मैं क्रोम का उपयोग कर रहा हूं
— Kritii Lithos
@KritiiLithos मेरी गलती है, एक अनावश्यक अल्पविराम था। फिक्स्ड
— edc65
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.