Моделюйте кубик Рубіка


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(p), L(eft), F(ront), R(ight), B(ack), D(own); 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

Правила

  • Не допускаються лазівки.
  • Це , тому найкоротший код у байтах, що вирішують проблему, виграє.


Чи можемо ми вибрати, щоб переорієнтувати куб (наприклад, з White U, Orange F та Green R)?
primo

Так, звичайно, поки вони відокремлені та впізнавані.
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і їх проти годинникової стрілки варіант з апострофа ( ')? Поза темою: Я завжди цікавлюсь питаннями, пов'язаними з Кубком Рубіка, ти також колекціонер Twisty Puzzles?
Кевін Круїйсен

3
@KevinCruijssen Dang, це багато головоломок.
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 байт.)

Повертає прямокутну рядок розміром 9x12.

Коротке пояснення

Це тісно базується на концепції моєї відповіді на це питання , яка, в свою чергу, грунтувалася на подібній концепції Яна Дворака.

Перший рядок генерує масив з 27 елементів, що представляє 27 кубиків. Кожна кубі представлена ​​3-мірним вектором, в якому знак представляє своє поточне положення, а величина кожної координати являє собою код ascii для кольору наклейки.

Приклад руху: для R для кожної кубіки перевірте, чи координата x> 0, і якщо так, поверніть на 90 градусів, поміняючи координати y і z і поміняючи знак однієї з них.

Візьміть пробіл розміром 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

Javascript (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}

Безголовки:

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 визначається вирішеним кубом. Куб представлений масивом, що містить 6 масивів, що містять 9 наклейок. Перший масив призначений для R, другий для U, третій для F, D, B, останній масив - для L. Коли y потрібно виконати, програма змінює чотири масиви передньої, лівої, задньої та правої частини обличчя. Для х він міняється спереду, вниз, назад і вгорі. Кожне обертання також обертає інші грані, які не змінювались. АР-хід обертає праве обличчя і змінює праву частину передньої, вгору, назад, обличчя вниз.

Це можна змінити, щоб мати змогу вирішувати проблеми з усіма типами рухів, визначаючи їх за допомогою x, y та R.


Я працюю над крадіжкою вашої концепції лише трьох кроків, щоб зробити своє коротше;) Чудова ідея
Аарон

Тож 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ес і ys дійсно гарні. Я теж хочу вкрасти це: p
betseg

@KevinCruijssen Повороти набагато простіше програмувати, ніж рухатися, впливаючи лише на один шар. Я спершу спробував цю концепцію з програмою для імітації кубів NxN, а тепер реалізував тут простішу версію. Спочатку він видаляє будь-які 'і 2, а потім замінює всі рухи.
Пол Шмітц

Молодці, але все-таки гольф. Я намагаюся перенести його на ES6
edc65

11

C, 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);
    }
}

4
Я не програміст C-, так поправте мене , якщо я помиляюся, але я вірю , що ви можете грати в гольф деякі з ваших для петель: 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)два рази. І я впевнений, що можна пограти ще трохи. Приємно бачити відповідь на власний виклик, хоча. :)
Кевін Круїссен

Я спробував гольфувати петлі вниз, але це не вийшло, тому я вирішив не чіпати їх. Я на вулиці і зараз не можу їх спробувати. Але ти маєш рацію щодо ifs, і iхоча я їх відредагую, як тільки повернусь додому. Спасибі!
betseg

@KevinCruijssen видаляє elses bork програму, петлі для гольфу обробляють програму, справа з iроботами. Все одно, дякую.
betseg

Хм, чому else ifзміна ifне вдається? : S У кожному з них else ifви порівнюєте d==##, тому я плутаюсь, чому це не так. Знову ж , я не програмую C, так що, може бути , я що - то очевидне отсутствую , що C не може зробити, але все ж .. Ах добре, радий , що я міг би допомогти з модулем <1замість==0
Кевін Cruijssen


9

Пітон 3,  610 563 533  526 байт

-7 байтів завдяки моїй колезі rhsmit (дуже хороша 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))

Суперліп і всі тести доступні на ideone або Спробуйте в Інтернеті!

Програма:

  • створює шість граней 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 байт

безсоромно вкрали ідею використовувати лише 3 обертання від @Paul Schmitz: D

Нова версія:

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))

неозорений ..

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

C, 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
}

Використовуйте лише один виклик одночасно, оскільки функція використовує та змінює глобальні змінні.

Безголовки:

#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
}

Як бачимо, основна ідея полягає у використанні повністю керованого даними підходу: різні обертання виражаються у вигляді списків індексів, які потрібно перестати переробляти. Код перестановки, таким чином, може бути дуже коротким та загальним.


2
Ласкаво просимо до PPCG! Гарний перший пост!
Rɪᴋᴇʀ

Ви можете зробити наступне, щоб зберегти більше байтів: f(h,g)int*g;{-2, l(g,m){-8, n(char*o){-5, printf("%s",a)до puts(a)-7, також ви можете замінити константи char на їх десятичне представлення ASCII -1
Khaled.K


5

Кубічно , 2 байти

¶■

Спробуйте в Інтернеті!

Пояснення:

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

Якщо дозволено сторонній вихід, це альтернатива. 1 байт:

Спробуйте в Інтернеті!

Кубічно автоматично скидає куб пам'яті, STDERRколи програма закінчується. Однак заздалегідь він друкує блокнот.


2
Я не знаю, чи аплодувати вам, чи гуляти. +1
Jo King

@JoKing Обидва. Так само, як і коли Кубічно виконує інші проблеми з кубом. 1 2 3
MD XF

4

JavaScript (ES6), 820

Передача помилкової відповіді від @Paul Schmitz. Це все ще не повністю гольф, але він має додаткову цінність, що працює.

Основна проблема оригінальної відповіді полягає в тому, що однієї функції Q недостатньо для всіх рухів, що беруть участь у обертанні. Мені довелося додати ще 2 функції O і N. Усі вони просто викликаються у правій функції обертання R.

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


Я отримую update(), що не визначено в моїй консолі під час запуску фрагмента
Kritixi Lithos

@KritixiLithos у вас, ймовірно, помилка sintax, оскільки у вас немає браузера, сумісного з ES6. Я перевірив це за допомогою Firefox, який браузер ви використовуєте?
edc65

Я використовую Chrome
Kritixi Lithos

@KritixiLithos, на мою провину, сталася непотрібна кома. Виправлено
edc65
Використовуючи наш веб-сайт, ви визнаєте, що прочитали та зрозуміли наші Політику щодо файлів cookie та Політику конфіденційності.
Licensed under cc by-sa 3.0 with attribution required.