একটি রুবিক কিউব অনুকরণ

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 শিল্প হিসাবে বা একটি চিত্র হিসাবে রূপান্তরিত করবে (হোয়াইটস্পেসগুলি প্রয়োজনীয় নয়, থাকতে পারে বা নাও থাকতে পারে, পেছনের শ্বেতস্থান অনুমোদিত)।

ইনপুটটি ঘূর্ণন হবে (এবং alচ্ছিক সংশোধক)। আবর্তন স্বরলিপিটি এর মতো হয়: 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
— betseg
আমরা কিউবটিকে পুনরায় ওরিয়েন্ট করার জন্য বেছে নিতে পারি (উদাহরণস্বরূপ, হোয়াইট ইউ, কমলা এফ, এবং গ্রিন আর)?
— প্রিমো
হ্যাঁ, অবশ্যই, যতক্ষণ না তারা পৃথক এবং স্বীকৃত।
— betseg
আমরা সমর্থন প্রয়োজন না S, E, M, x, y, z, u/ Uw, d/ Dw, r/ Rw, l/ Lw, f/ Fw, b/ Bwপাশাপাশি প্যাচসমূহ? অথবা শুধুমাত্র ডিফল্ট: U, D, R, L, F, Bএবং ঊর্ধকমা সঙ্গে তাদের বামাবর্তে বৈকল্পিক ( ')? অফ-টপিক: আমি সবসময় রুবিকের কিউব সম্পর্কিত প্রশ্নগুলি নিয়ে অবাক হই, আপনি কি টুইস্টি ধাঁধা সংগ্রহকারী?
— কেভিন ক্রুইজসেন
3
@ কেভিন ক্রুজসেন ডাং, এটি অনেক ধাঁধা।
— mbomb007

উত্তর:

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 বাইট থাকে is)

একটি 9x12 আয়তক্ষেত্রাকার স্ট্রিং প্রদান করে।

সংক্ষিপ্ত বর্ণনা

এটি এই প্রশ্নের আমার উত্তর থেকে একটি ধারণার উপর ঘনিষ্ঠভাবে ভিত্তি করে গড়ে উঠেছে , যা ঘুরে দেখা গেছে জ্যান ডিভোরাকের অনুরূপ ধারণার ভিত্তিতে।

প্রথম লাইন 27 টি ঘনক্ষেত্রকে উপস্থাপন করে একটি 27 উপাদান অ্যারে তৈরি করে। প্রতিটি কিউবিকে 3 টি মাত্রিক ভেক্টর দ্বারা প্রতিনিধিত্ব করা হয় যেখানে সাইনটি তার বর্তমান অবস্থানটি উপস্থাপন করে এবং প্রতিটি স্থানাঙ্কের দৈর্ঘ্য স্টিকারের রঙের জন্য এসকি কোডটি উপস্থাপন করে।

উদাহরণস্বরূপ পদক্ষেপ: আর এর জন্য, প্রতিটি কিউবি চেকের জন্য 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

জাভাস্ক্রিপ্ট (ES5), 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")।

প্রোগ্রামটি কেবল এক্স, ওয়াই এবং আর চালগুলি কার্যকর করতে পারে।

U'সমান U U U, সুতরাং যে প্রতিস্থাপন।

Fসমান y y y R y, সুতরাং যে প্রতিস্থাপন।

R U' F'সুতরাং R U U U y y y R yপ্রোগ্রামটি চালাতে পারে যা সমান ।

সিস্টেট একটি সমাধান কিউব দিয়ে সংজ্ঞায়িত করা হয়। 9 টি স্টিকারযুক্ত 6 টি অ্যারে সমন্বিত একটি অ্যারের দ্বারা একটি কিউব প্রতিনিধিত্ব করা হয়। প্রথম অ্যারে আর এর জন্য দ্বিতীয়, ইউ এর জন্য তৃতীয়, এফ, ডি, বি, শেষ অ্যারেটি এল এর জন্য যখন একটি ওয়াই কার্যকর করা দরকার তখন প্রোগ্রামটি সামনে, বাম, পিছনে এবং ডান মুখের চারটি অ্যারে অদলবদল করে। এক্স এর জন্য, এটি সামনে, নীচে, পিছনে এবং উপরের দিকে অদলবদল করে। প্রতিটি ঘোরানো অন্যান্য মুখগুলিও ঘোরায়, সেগুলি অদলবদল করা হয়নি। এআর সরানো ডান মুখটি ঘোরায় এবং সামনের ডান অংশটি, উপরে, পিছনে, নীচের দিকে অদলবদল করে।

এটি এক্স, ওয়াই এবং আর এর মাধ্যমে সংজ্ঞায়িত করে, সমস্ত ধরণের পদক্ষেপের সাথে সমস্যার সমাধান করতে সক্ষম হতে সংশোধন করা যেতে পারে

— পল স্মিটজ
সূত্র
আমি নিজের সংক্ষিপ্ততর করার জন্য আপনার কেবল 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 :) আপনি কীভাবে এই ধারণাটি নিয়ে এসেছেন?
— কেভিন ক্রুইজসেন
2
আমার কোডটিও রূপান্তরিত U'হয় U U Uতবে xএস এবং yএসগুলি খুব ভাল। আমি এটিও চুরি করতে চাই: পি
— betseg
কেবলমাত্র একটি স্তরকে প্রভাবিত করার চেয়ে @ কেভিন ক্রুইজসেন ঘূর্ণনগুলি প্রোগ্রাম করা আরও সহজ। আমি প্রথমে এনএক্সএন কিউবগুলি অনুকরণের জন্য একটি প্রোগ্রামের মাধ্যমে এই ধারণাটি চেষ্টা করেছি এবং এখন এখানে একটি সহজ সংস্করণ প্রয়োগ করেছি। এটি প্রথমে যেকোন 'এবং সরিয়ে দেয় 2এবং তারপরে সমস্ত চলন প্রতিস্থাপন করে।
— পল স্মিটজ
ভাল হয়েছে কিন্তু এখনও গল্ফযোগ্য। আমি এটিকে ES6
— এডক 65
11

সি, 1715 1709 1686 1336 1328 বাইট

25 কেভিট ক্রুইজসেনকে ধন্যবাদ বাইটস সংরক্ষণ করেছে!

এখন পর্যন্ত কোনও উত্তর নেই, তাই আমি নিজের সমাধানটি স্থির করার সিদ্ধান্ত নিয়েছি।

#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)দুই বার। এবং আমি নিশ্চিত এটি আরও কিছু গল্ফ করা যেতে পারে। যদিও আপনার নিজের চ্যালেঞ্জের উত্তর দেখে ভাল লাগছে। :)
— কেভিন ক্রুইজসেন
আমি লুপগুলি নীচে গল্ফ করার চেষ্টা করেছি, তবে এটি কার্যকর হয়নি, তাই আমি তাদের স্পর্শ না করার সিদ্ধান্ত নিয়েছি। আমি বাইরে আছি এবং এখনই তাদের চেষ্টা করতে পারি না। তবে আপনি ঠিক কথা বলছেন ifএবং iযাইহোক, আমি ঘরে ফিরে একবার এগুলি সম্পাদনা করব। ধন্যবাদ!
— betseg
@ কেভিন ক্রুইজসেন এই বার্কটিকে সরিয়ে দিচ্ছেন else, গল্ফিং লুপগুলি কর্মসূচিকে উদ্বুদ্ধ করে , iকাজের সাথে কাজ করে। যাই হোক ধন্যবাদ.
— betseg
হুঁ, কেন else ifপরিবর্তন ifব্যর্থ হয়? : এস else ifআপনি d==##যে কোনও একটির সাথে তুলনা করেন , তাই আমি কেন বিভ্রান্ত না হয়ে থাকি। আবার, আমি সি প্রোগ্রাম করি না, তাই সম্ভবত আমি <1==0
— স্পষ্টত
1
— সিলিংক্যাট
9

পাইথন 3,  610 563 533  526 বাইট

-7 বাইটস আমার সহকর্মী rhmits ধন্যবাদ (সত্যিই দুর্দান্ত 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ঘড়ির কাঁটার দিকে ঘুরিয়ে ঘুরিয়ে ঘড়ির কাঁটার দিকে চতুর্থাংশ ঘুরিয়ে দেয় quarter
  • একটি ফাংশন, সৃষ্টি 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(যা এখন মুখের নির্দেশ হবে) এবং তারপরে সেটআপের ক্রমটিকে বিপরীতমুখী করার জন্য কলগুলি নির্দেশ করে map মাধ্যমে মুখ চরিত্র মডিউল এর পূরণবাচক গ্রহণ 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 বাইট

@ পাল স্কিটিজ: ডি থেকে মাত্র 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। এটি তিন ধরণের আবর্তন ব্যবহার করে।
— পল স্মিটজ
@ পলশ্মিটজ তিন ধরণের মানে যা বোঝাতে চেয়েছিলেন .... রূপান্তরগুলি সপ্তম লাইনের স্ট্রিং-এ তালিকাভুক্ত করা হয়েছে
— অ্যারন
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
পিপিসিজিতে আপনাকে স্বাগতম! প্রথম প্রথম পোস্ট!
— Rɪᴋᴇʀ
আরও বাইট সংরক্ষণের জন্য আপনি নিম্নলিখিতটি করতে পারেন: f(h,g)int*g;{-২, l(g,m){-8, n(char*o){-5, printf("%s",a)থেকে puts(a)-7, আপনি
— চার্ট কনস্ট্যান্টগুলি
— সিলিংক্যাট
5

কিউবিকভাবে , 2 বাইট

¶■

এটি অনলাইন চেষ্টা করুন!

ব্যাখ্যা:

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

যদি বহিরাগত আউটপুট অনুমোদিত হয়, তবে এটি বিকল্প। 1 বাইট:

এটি অনলাইন চেষ্টা করুন!

STDERRপ্রোগ্রামটি শেষ হওয়ার পরে কিউবিকালি স্বয়ংক্রিয়ভাবে এর মেমরি ঘনকটি ফেলে দেয় । তবে এটি আগে থেকে নোটপ্যাডও মুদ্রণ করে।

— এমডি এক্সএফ
সূত্র
2
আপনাকে সাধুবাদ জানানো বা গড়াগড়ি করা আমি জানি না। +1
— জো কিং
পুনঃটুইট করেছেন ঠিক কীভাবে যখন ঘনক্ষেত্রে অন্যান্য কিউব চ্যালেঞ্জগুলি বন্ধ করে দেয় w 1 2 3
— এমডি এক্সএফ
4

জাভাস্ক্রিপ্ট (ES6), 820

@ পল শ্মিত্জের বগী উত্তরের একটি পোর্টিং। এটি এখনও পুরোপুরি গল্ফ হয়নি, তবে এটির সাথে এটির অতিরিক্ত মূল্য রয়েছে।

মূল উত্তরের প্রধান সমস্যাটি হ'ল একটি ঘূর্ণনের সাথে জড়িত সমস্ত আন্দোলনের জন্য একটি একক ফাংশন Q যথেষ্ট নয়। আমাকে ও অন্যান্য 2 টি ফাংশন যুক্ত করতে হয়েছিল তাদের সমস্তকে কেবল ডান রোটেশন ফাংশন আর বলা হয় called

(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()স্নিপেট চালানোর সময় আমার কনসোলে সংজ্ঞায়িত করা হয় না
— Kritixi Lithos
ES6 কমপ্লায়েন্ট ব্রাউজার না থাকার জন্য @ ক্রিটিক্সিলিথোস আপনার সম্ভবত একটি সিনট্যাক্স ত্রুটি রয়েছে। আমি এটি ফায়ারফক্সের সাথে পরীক্ষা করেছি, আপনি কোন ব্রাউজারটি ব্যবহার করছেন?
— edc65
আমি ক্রোম ব্যবহার করছি
— ক্রিটিক্সী লিথোস
@ ক্রিতিক্সিলিথোস আমার দোষ, একটি অপ্রয়োজনীয় কমা ছিল। স্থির
— edc65
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.