루빅스 큐브 해결

38

합리적인 시간과 이동 시간 내에서 Rubik의 큐브 (3 * 3 * 3)를 해결하는 가장 짧은 프로그램을 작성하십시오 (예 : 기계에서 최대 5 초, 1000 미만).

입력 형식은 다음과 같습니다.

UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR

이 특정 입력은 해결 된 큐브를 나타냅니다.
처음 12 개의 2 문자열은 UF, UR, ... BL 위치의 가장자리입니다 (U = 위, F = 앞면, R = 오른쪽, B = 뒤쪽, L = 왼쪽, D = 아래). 3 문자열은 UFR, URB, ... DBR 위치의 모서리입니다.

출력은 다음 형식으로 일련의 이동을 제공해야합니다.

D+ L2 U+ F+ D+ L+ D+ F+ U- F+

D1 또는 D +는 D (아래)면을 시계 방향으로 90도 돌리는 것을 나타내고 L2는 L면을 180도 돌리고, U3 또는 U-는 U면을 시계 반대 방향으로 90도 돌리는 것을 나타냅니다.
문자는 대소 문자를 구분하지 않으며 공백은 선택 사항입니다.

예를 들어, 위의 출력은 다음 입력에 적합합니다.

RU LF UB DR DL BL UL FU BD RF BR FD LDF LBD FUL RFD UFR RDB UBL RBU

자세한 내용 은 일반적인 코드 골프 문제와 같이 파일 크기로 직접 점수를 매기는 것을 제외하고는 Tomas Rokicki의 큐브 콘테스트 를 참조하십시오 . 온라인 테스터 도 포함되어 있습니다.

참고로 이미 작성된 가장 짧은 솔루션은 큐브 콘테스트 수상자 목록의 마지막 항목입니다.

레이아웃 형식을 시각화하는 데 어려움을 겪고있는 사람들을 위해 :

0-1 2-3 4-5 6-7 8-9 10-11 12-13 14-15 16-17 18-19 20-21 22-23 24-25-26 27-28-29 30-31-32 33-34-35 36-37-38 39-40-41 42-43-44 45-46-47
UF  UR  UB  UL  DF   DR    DB   DL    FR    FL     BR    BL     UFR      URB      UBL      ULF      DRF      DFL      DLB      DBR

Front:

                 +-------+-------+-------+
                /       /       /       /|
               /  30   /   4   /  27   / |
              +-------+-------+-------+  |
             /       /       /       /|28+
            /   6   /       /   2   / | /|
           +-------+-------+-------+  |/ |
          /       /       /       /|3 +  |
         /  33   /   0   /  24   / | /|21+
        +-------+-------+-------+  |/ | /|
        |       |       |       |26+  |/ |
        |  35   |   1   |   25  | /|  +  |
        |       |       |       |/ | /|47+
        +-------+-------+-------+  |/ | /
        |       |       |       |17+  |/
        |  18   |       |  16   | /|11+
        |       |       |       |/ | /
        +-------+-------+-------+  |/
        |       |       |       |37+
        |  40   |   9   |  38   | /
        |       |       |       |/
        +-------+-------+-------+


Hidden faces:

                 +-------+-------+-------+
                /|       |       |       |
               / |  31   |   5   |  29   |
              +  |       |       |       |
             /|32+-------+-------+-------+
            / | /|       |       |       |
           +  |/ |  22   |       |  20   |
          /|7 +  |       |       |       |
         / | /|23+-------+-------+-------+
        +  |/ | /|       |       |       |
        |34+  |/ |  44   |  13   |  46   |
        | /|  +  |       |       |       |
        |/ | /|43+-------+-------+-------+
        +  |/ | /       /       /       /
        |19+  |/  42   /  12   /  45   /
        | /|15+-------+-------+-------+
        |/ | /       /       /       /
        +  |/  14   /       /  10   /
        |41+-------+-------+-------+
        | /       /       /       /
        |/  39   /   8   /   36  /
        +-------+-------+-------+
code-golf  puzzle-solver  rubiks-cube  restricted-time  code-bowling  code-golf  ascii-art  code-challenge  code-golf  c  code-golf  hello-world  code-golf  string  decision-problem  code-challenge  primes  number-theory  code-golf  code-golf  python  pi  code-golf  graphical-output  game  atomic-code-golf  whitespace  balanced-string  code-golf  geometry  code-golf  optimization  board-game  puzzle-solver  fastest-code  primes  code-challenge  code-golf  hello-world  polyglot  code-golf  cryptography  code-golf  javascript 
— 아디 츠
소스
3
C / C ++ / Java / Perl / Python 이외의 언어가 허용됩니까?
— Egor Skriptunoff
@EgorSkriptunoff 여기서 예, 큐브 풀기 라이브러리없이 원하는 것을 사용하십시오.
— aditsu
그리고 점수는 어떻습니까? 2004 년 경연 대회와 같은 일반적인 코드 골프 점수 (프로그램의 바이트 수) 또는 복잡한 점수는?
— Egor Skriptunoff
2
@jdstankosky, 다이어그램을 추가했습니다.
— 피터 테일러
7
스티커를 빼내고 움직일 수 있습니까?
— Iszi

답변:

25

C ++-1123

지금까지 아무도 답변을 게시하지 않았기 때문에 2004 솔루션을 단순화하고 골프하기로 결정했습니다. 그것은 내가 질문에서 언급 한 가장 짧은 것보다 훨씬 늦습니다.

#include<iostream>
#include<vector>
#define G(i,x,y)for(int i=x;i^y;i++)
#define h(x)s[a[x]/q*q+(a[x]+j)%q-42]
#define B(x)D=x;E=O.substr(j*3,3);G(i,0,3)E+=F[5-F.find(E[2-i])];G(i,0,D.length())D[i]=E[F.find(D[i++])];m.push_back(D);
#define P(a,b)G(i,0,6)G(k,49,52){e[0]=F[i];e[1]=k;m.push_back(e);}G(j,0,24){B(a)B(b)}
#define T C();z=m.size();for(b=c;b;){d=s;G(i,o=w=1,4){w*=z;if(o)G(j,0,w)if(o){s=d;u=j;G(k,0,i){f=m[u%z];G(x,0,f.length()){a=M[F.find(f[x++])];G(i,0,f[x]-48)G(l,0,2){q=3-l;p=4*l;G(j,0,q){t=h(p+3);G(k,-3,0)h(p-k)=h(p-1-k);h(p)=t;}}}u/=z;}C();if(c<b){u=j;G(k,0,i){std::cout<<m[u%z];u/=z;}b=c;o=0;}}}}
std::string s,a,D,E,d,f,e="  ",S="UFURUBULDFDRDBDLFRFLBRBLUFRURBUBLULFDRFDFLDLBDBR",F="ULFBRD",M[]={"KHEB*0.,","KRTI0<8@","KDNS*;2=","IVXG/@7>","BGWP,>4:","QNWT2468"},O=S.substr(24)+"FDRFRUFULFLDRDBRBURUFRFDBDLBLUBURBRDLDFLFULUBLBD";std::vector<std::string>m;int
w,X=8,Y=16,o,c,u,b,z,p,q,t;void C(){c=0;G(i,X,Y)c+=s[i]!=S[i];}main(int
g,char**v){G(i,1,g)s+=v[i];P("U2F1R1L3U2L1R3F1U2","L3R1F3L1R3D2L3R1F3L1R3");T;Y=24;T;X=0;T;m.clear();P("R3D3R1D3R3D2R1L1D1L3D1L1D2L3","R1F3L3F1R3F3L1F1");G(I,5,9){Y=I*6;T}}

무작위는 아니지만 간단하게 진행되지도 않습니다. 먼저 모서리를 해결 한 다음 모서리를 해결합니다. 각 단계에서 최대 4 개의 알고리즘과 간단한 얼굴 회전 (연속적으로 무작위가 아닌)의 다양한 조합을 시도하여 해결 된 조각 수의 개선을 찾은 다음 해결 될 때까지 반복합니다. 모서리에 대해 2 개의 알고리즘을 사용하고 모서리에 대해 2 개의 알고리즘을 사용하여 모든 큐브 위치로 변환합니다.

의 출력 예 RU LF UB DR DL BL UL FU BD RF BR FD LDF LBD FUL RFD UFR RDB UBL RBU:

L2F3B2F3B1U3F1B3R2F3B1U3F1B3D2F2L3D2L1U2B1L1R3U2R1L3B1U2R1U2L1F1B3U2B1F3L1U2L3R1D3L1R3B2L3R1D3L1R3L3R1D3L1R3B2L3R1D3L1R3B3F1D3B1F3R2B3F1D3B1F3U2F3L3R1B3L1R3U2L3R1B3L1R3F1D2F1L1R3D2R1L3F1D2F3L2U1B1F3L2F1B3U1L2R3L1F3R1L3U2R3L1F3R1L3U1F2U1L1R3F2R1L3U1F2U3L3U3L1U3L3U2L1R1U1R3U1R1U2R3F3U3F1U3F3U2F1B1U1B3U1B1U2B3L1B3R3B1L3B3R1B1B3D3B1D3B3D2B1F1D1F3D1F1D2F3R1F3L3F1R3F3L1F1R3B3R1B3R3B2R1L1B1L3B1L1B2L3R1D3L3D1R3D3L1D1B3D3B1D3B3D2B1F1D1F3D1F1D2F3U3R3U1R3U3R2U1D1R1D3R1D1R2D3

(234 이동, 0.3 초)

— 아디 츠
소스
2
당신은 무엇을 알고 있습니까 ... 몇 초 안에 또 다른 답변이 게시되었습니다 :)
— aditsu
이것이 루비 솔루션보다 길지만 "합리적인 시간과 이동 안에" 문제 기준에 더 잘 맞는다고 생각합니다 . 그래도 여전히 ~ 50 움직임 이하의 솔루션을보고 싶습니다.
— primo
2
@primo Thanks :) 내 원래 코드는 평균 50 번 이상 이동했습니다 .50 미만에서는 더 많은 (큐브) 알고리즘이나 Thistlethwaite의 방법과 같은 다른 접근법이 필요하다고 생각합니다. 그러나 효율성 (이동 횟수)은 골프와 매우 호환되지 않습니다. 어쨌든 대안 솔루션을 보려면 Tomas Rokicki의 콘테스트에서 우승 한 사람을 확인하십시오.
— aditsu
23

파이썬 1166 바이트

가독성을 위해 상당한 양의 공백이 남아 있습니다. 크기는이 공백을 제거하고, 다양한 들여 쓰기 수준을 변경 한 후 측정 Tab, Tab Space, Tab Tab또한 너무 크게 성능에 영향을받는 골프를 피할 것 등 I.

T=[]
S=[0]*20,'QTRXadbhEIFJUVZYeijf',0
I='FBRLUD'

G=[(~i%8,i/8-4)for i in map(ord,'ouf|/[bPcU`Dkqbx-Y:(+=P4cyrh=I;-(:R6')]
R=range

def M(o,s,p):
 z=~p/2%-3;k=1
 for i,j in G[p::6]:i*=k;j*=k;o[i],o[j]=o[j]-z,o[i]+z;s[i],s[j]=s[j],s[i];k=-k

N=lambda p:sum([i<<i for i in R(4)for j in R(i)if p[j]<p[i]])

def H(i,t,s,n=0,d=()):
 if i>4:n=N(s[2-i::2]+s[7+i::2])*84+N(s[i&1::2])*6+divmod(N(s[8:]),24)[i&1]
 elif i>3:
  for j in s:l='UZifVYje'.find(j);t[l]=i;d+=(l-4,)[l<4:];n-=~i<<i;i+=l<4
  n+=N([t[j]^t[d[3]]for j in d])
 elif i>1:
  for j in s:n+=n+[j<'K',j in'QRab'][i&1]
 for j in t[13*i:][:11]:n+=j%(2+i)-n*~i
 return n

def P(i,m,t,s,l=''):
 for j in~-i,i:
  if T[j][H(j,t,s)]<m:return
 if~m<0:print l;return t,s
 for p in R(6):
  u=t[:];v=s[:]
  for n in 1,2,3:
   M(u,v,p);r=p<n%2*i or P(i,m+1,u,v,l+I[p]+`n`)
   if r>1:return r

s=raw_input().split()
o=[-(p[-1]in'UD')or p[0]in'RL'or p[1]in'UD'for p in s]
s=[chr(64+sum(1<<I.find(a)for a in x))for x in s]

for i in R(7):
 m=0;C={};T+=C,;x=[S]
 for j,k,d in x:
  h=H(i,j,k)
  for p in R(C.get(h,6)):
   C[h]=d;u=j[:];v=list(k)
   for n in i,0,i:M(u,v,p);x+=[(u[:],v[:],d-1)]*(p|1>n)
 if~i&1:
  while[]>d:d=P(i,m,o,s);m-=1
  o,s=d

샘플 사용법 :

$ more in.dat
RU LF UB DR DL BL UL FU BD RF BR FD LDF LBD FUL RFD UFR RDB UBL RBU

$ pypy rubiks.py < in.dat
F3R1U3D3B1
F2R1F2R3F2U1R1L1
R2U3F2U3F2U1R2U3R2U1
F2L2B2R2U2L2D2L2F2

이것은 각 단계에 대해 해결하기 위해 IDA * 검색을 사용하여 Thistlethwaite의 알고리즘을 구현 한 것입니다. 모든 휴리스틱 테이블을 즉석에서 계산해야하므로 몇 가지 타협이 이루어졌으며 일반적으로 휴리스틱을 두 개 이상의 동일한 크기의 부분으로 나눕니다. 이렇게하면 휴리스틱 테이블의 계산이 수백 배 더 빨라지지만 검색 단계가 느려지지만 일반적으로 약간만 수행되지만 초기 큐브 상태에 따라 중요 할 수 있습니다.

변수 인덱스

  • T -주요 휴리스틱 테이블.
  • S-해결 된 큐브 상태. 각 개별 조각은 문자로 표시되는 비트 마스크로 저장됩니다. 해결 된 오리엔테이션 벡터는 0 벡터로 정의됩니다.
  • I -검색 공간에서 제거되는 순서로 다양한 왜곡.
  • G-교환 될 쌍으로 저장된 트위스트 순열 그룹. 압축 된 문자열의 각 바이트는 한 쌍으로 인코딩됩니다. 각 꼬임에는 6 개의 스왑이 필요합니다. 3 개는 에지 사이클, 3 개는 코너 사이클입니다. 압축 된 문자열에는 인쇄 가능한 ASCII 만 포함됩니다 (char 32 ~ 126).
  • M -G에 의해 주어진 이동을 수행하는 함수
  • N -인코딩 목적으로 4 개의 객체 순열을 숫자로 변환합니다.
  • H -주어진 큐브 상태에 대한 휴리스틱 값을 계산하며 T에서 이동 깊이를 조회하는 데 사용됩니다.
  • P -알고리즘의 단일 단계의 단일 깊이에서 검색을 수행합니다.
  • s -입력 큐브의 순열 상태.
  • o -입력 큐브의 방향 벡터.

공연

사용 토마스 로키 키의 데이터 세트를 ,이 스크립트는 472ms의 평균 시간, 해결 당 16.02 꼬임 (최대 35) 평균 (i5-3330 CPU @ 3.0 GHz의, PyPy 1.9.0). 최소 해결 시간은 233ms이며 최대 2.97 초, 표준 편차 0.488입니다. 공모전의 점수 지침 (공백은 계산되지 않고 키워드 및 식별자는 길이가 870 인 경우 1 바이트로 계산 됨)을 사용하면 전체 점수는 13,549입니다.

마지막 46 개 사례 (임의의 상태)의 경우 평균 시간은 721ms 인 평균 해마다 30.83 회 트위스트되었습니다.

Thistlethwaite의 알고리즘에 대한 참고 사항

Thistlethwaite 's Algorithm 의 구현을 시도하려는 모든 사람을 위해 간단한 설명이 있습니다.

이 알고리즘은 매우 간단한 솔루션 공간 축소 원칙에 따라 작동합니다. 즉, 큐브를 풀기 위해 꼬임의 하위 세트가 필요하지 않은 상태로 큐브를 줄이고 더 작은 솔루션 공간으로 줄인 다음 남은 꼬임 만 사용하여 나머지를 해결하십시오.

Thistlethwaite는 원래 <L,R,F,B,U,D>→ <L,R,F,B,U2,D2>→ <L,R,F2,B2,U2,D2>→ 제안했습니다 <L2,R2,F2,B2,U2,D2>. 그러나 입력 형식을 고려할 때 먼저 <L,R,F2,B2,U,D>(쿼터 턴 F또는 B)로 줄이고 , <L2,R2,F2,B2,U,D>마지막으로 하프 턴 상태에 도달하기 가 더 쉽다고 생각합니다 . 이것이 왜 정확한지를 설명하는 대신, 각 주에 대한 기준을 정의한 후에 분명해질 것이라고 생각합니다.

<L,R,F,B,U,D> ⇒ <L,R,F2,B2,U,D>

회전 을 제거 F하고 B1/4 회전하려면 가장자리 만 올바르게 향해야합니다. Gilles Roux는 자신의 사이트 에서 '올바른'방향과 '올바르지 않은'방향 에 대해 매우 잘 설명하고 있으므로 설명을 그에게 맡기겠습니다. 그러나 기본적으로 (그리고 이것이이 입력 형식이 그렇게 결정 F적이고 B제거 되는 이유입니다 ), 가장자리 cubie는 다음 정규 표현식과 일치하면 올바르게 지향됩니다 [^RL][^UD]. 올바른 방향은 일반적으로로 표시 0되고로 잘못 표시됩니다 1. 기본적 U와 D스티커는 나타나지 않을 수 R또는 L얼굴, 또는 어느 하나의 가장자리에 U또는 D가장자리 cubies, 또는 그들은 필요하지 않고 장소로 이동 될 수없는 F또는B 쿼터 트위스트.

<L,R,F2,B2,U,D> ⇒ <L2,R2,F2,B2,U,D>

여기에 두 가지 기준이 있습니다. 첫째, 모든 모서리가 올바른 방향으로해야하며, 둘째, 중간 계층 cubies에 대한 각 ( FR, FL, BR, BL) 중간 계층 어딘가에 있어야합니다. 코너 오리엔테이션은 입력 형식에 따라 매우 간단하게 정의됩니다 : 첫 번째 U또는 의 위치 D. 예를 들어, URB방향 0(정확한 방향), LDF방향 1및 LFU방향을가 2집니다.

<L2,R2,F2,B2,U,D> ⇒ <L2,R2,F2,B2,U2,D2>

여기에서 기준은 다음과 같습니다. 각 얼굴에는 얼굴 또는 얼굴 바로 맞은 얼굴의 스티커 만 포함될 수 있습니다. 예를 들어,에 U얼굴 만있을 수 U및 D스티커, 온 R얼굴 만있을 수 R와 L스티커, 온 F얼굴 만있을 수 F및 B각 모서리 부분이있는 경우 스티커 등이 보장하는 가장 쉬운 방법은 확인할 그것의 '슬라이스', 그리고 그것의 '궤도'의 각 코너 조각. 또한 에지 코너 패리티에주의를 기울여야합니다. 코너 패리티 만 확인하면 에지 패리티도 보장되며 그 반대도 마찬가지입니다.

꼬임이 방향에 미치는 영향

U와 D왜곡은 에지 방향이나 모서리 방향도 영향을 미친다. 방향 벡터를 업데이트하지 않고 조각을 직접 교체 할 수 있습니다.

R와 L왜곡은 가장자리 방향에 영향을 미치지 않습니다,하지만 그들은 코너 방향에 영향을 미치지 않습니다. 사이클 정의 방법에 따라 코너 방향의 변경은 +1, +2, +1, +2또는 +2, +1, +2, +1모두 모듈로 3입니다. 주의 R2와 L2같은 왜곡이 모서리 방향에 영향을 미치지 않는 +1+2제로 모듈이다가 3,있는 그대로 +2+1.

F및 B에지 방향과 모서리 방향 모두에 영향을 미칩니다. 에지 방향이되고 +1, +1, +1, +1(모드 2), 및 코너 방위는와 동일 R하고 L. 참고 F2및 B2가장자리 방향,도 코너 방향도 영향을 미친다.

— 프리모
소스
훌륭한 글쓰기. Kociemba의 알고리즘에 대해 들어 보셨습니까?
— 마일
나는 가지고있다. 원칙적으로 4 단계 대신 두 개의 알고리즘 만 있습니다 <L,R,F,B,U,D>.-> <L2,R2,F2,B2,U,D>-> <I>. 큐브를 해결하기 위해 최대 29 번의 꼬임이 필요하지만 (Thistlethwaite의 경우 52 대신) 매우 큰 조회 테이블이 필요하기 때문에 '즉석에서'생성하기에는 비실용적입니다.
— primo
@ P0W 입력 형식이 약간 혼란 스럽습니다. 오류가있을 수 있습니다. 내가 확인한 모든 경우에 해결책이됩니다.
— primo
@primo 골프 용이 아닌 코드에 대한 링크를 게시 하시겠습니까?
— Bilow
12

루비, 742 자

r=->y{y.split.map{|x|[*x.chars]}}
G=r['UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR']
o=r[gets]
x=[];[[%w{U UU UUU L LL LLL}+D=%w{D DD DDD},0],[%w{FDFFF RFDFFFRRR}+D,12],[%w{DDDRRRDRDFDDDFFF DLDDDLLLDDDFFFDF}+D,8],[%w{DFLDLLLDDDFFF RDUUUFDUUULDUUUBDUUU}+D,4],[%w{LDDDRRRDLLLDDDRD RRRDLDDDRDLLLDDD LFFFLLLFLFFFLLLF},16]].map{|q,y|x+=[*y..y+3]
3.times{q.map{|e|q|=[e.tr('LFRB','FRBL')]}}
w=->u{x.count{|t|u[t]!=G[t]}}
s=w[o]
(c=(0..rand(12)).map{q.sample}*''
z=o
c.chars{|m|z="=$'*:036\".?BOHKVGRWZ!$@*-0C69<4(E\\INQTMX!$'B-03<9*?6EHYLQPUZ!9'*-?360<$BSFKN[TWJ$'*!-0369<?BHKNEQTWZ!$'*6-039<?BEHKNTWZQ"[20*('FBLRUD'=~/#{m}/),20].bytes.map{|e|z[e/3-11].rotate e%3}}
t=w[z]
(c.chars{|e|$><<e<<'1 '};o=z;s=t)if s>t
)until s<1}

위의 루비 코드는 아직 완전히 골프화되지 않았습니다. 코드를 더 향상시킬 가능성은 여전히 ​​있습니다 (그러나 이미 초보자로 충분합니다).

큐브를 레이어별로 해결하지만 특정 알고리즘을 사용하지 않고 큐브가 해결 될 때까지 임의의 이동 시퀀스를 수행합니다.

확률 적 특성으로 인해 큐브를 해결하는 데 때때로 5 초 이상이 소요될 수 있으며 드물게 1000 회 이상 이동합니다.

출력 예 (입력 'RU LF UB DR DL BL UL FU BD RF BR FD LDF LBD FUL RFD UFR RDB UBL RBU')는 757 이동입니다.

F1 R1 R1 F1 F1 F1 R1 R1 R1 L1 L1 L1 F1 D1 L1 L1 D1 D1 D1 D1 L1 B1 D1 
B1 B1 B1 L1 L1 L1 F1 D1 F1 F1 F1 L1 D1 L1 L1 L1 B1 D1 B1 B1 B1 R1 D1 
R1 R1 R1 L1 B1 D1 B1 B1 B1 L1 L1 L1 D1 D1 B1 D1 B1 B1 B1 B1 D1 B1 B1 
B1 L1 D1 L1 L1 L1 D1 D1 D1 D1 D1 R1 D1 R1 R1 R1 R1 F1 D1 F1 F1 F1 R1 
R1 R1 R1 D1 R1 R1 R1 F1 L1 D1 L1 L1 L1 F1 F1 F1 D1 D1 D1 D1 L1 D1 L1 
L1 L1 F1 L1 D1 L1 L1 L1 F1 F1 F1 D1 D1 L1 D1 L1 L1 L1 D1 L1 D1 L1 L1 
L1 L1 D1 L1 L1 L1 D1 R1 D1 D1 D1 R1 R1 R1 D1 D1 D1 B1 B1 B1 D1 B1 D1 
L1 D1 D1 D1 L1 L1 L1 D1 D1 D1 F1 F1 F1 D1 F1 D1 D1 D1 B1 B1 B1 D1 B1 
D1 R1 D1 D1 D1 R1 R1 R1 D1 D1 D1 B1 B1 B1 D1 B1 D1 R1 D1 D1 D1 R1 R1 
R1 D1 B1 D1 D1 D1 B1 B1 B1 D1 D1 D1 L1 L1 L1 D1 L1 D1 B1 D1 D1 D1 B1 
B1 B1 D1 D1 D1 L1 L1 L1 D1 L1 D1 D1 F1 D1 D1 D1 F1 F1 F1 D1 D1 D1 R1 
R1 R1 D1 R1 D1 D1 D1 R1 R1 R1 D1 R1 D1 F1 D1 D1 D1 F1 F1 F1 D1 B1 D1 
D1 D1 B1 B1 B1 D1 D1 D1 L1 L1 L1 D1 L1 D1 D1 D1 F1 F1 F1 D1 F1 D1 L1 
D1 D1 D1 L1 L1 L1 D1 D1 D1 D1 D1 D1 F1 F1 F1 D1 F1 D1 L1 D1 D1 D1 L1 
L1 L1 D1 D1 D1 F1 F1 F1 D1 F1 D1 L1 D1 D1 D1 L1 L1 L1 D1 F1 D1 D1 D1 
F1 F1 F1 D1 D1 D1 R1 R1 R1 D1 R1 D1 D1 D1 F1 F1 F1 D1 F1 D1 L1 D1 D1 
D1 L1 L1 L1 D1 D1 D1 F1 F1 F1 D1 F1 D1 L1 D1 D1 D1 L1 L1 L1 D1 D1 D1 
D1 D1 F1 F1 F1 D1 F1 D1 L1 D1 D1 D1 L1 L1 L1 D1 D1 D1 D1 D1 D1 R1 F1 
D1 F1 F1 F1 D1 D1 D1 R1 R1 R1 D1 F1 L1 D1 L1 L1 L1 D1 D1 D1 F1 F1 F1 
D1 B1 R1 D1 R1 R1 R1 D1 D1 D1 B1 B1 B1 D1 B1 R1 D1 R1 R1 R1 D1 D1 D1 
B1 B1 B1 D1 D1 D1 D1 B1 R1 D1 R1 R1 R1 D1 D1 D1 B1 B1 B1 D1 D1 D1 D1 
D1 D1 B1 B1 B1 D1 F1 D1 D1 D1 B1 D1 F1 F1 F1 D1 D1 D1 R1 R1 R1 D1 L1 
D1 D1 D1 R1 D1 L1 L1 L1 D1 D1 D1 B1 D1 D1 D1 F1 F1 F1 D1 B1 B1 B1 D1 
D1 D1 F1 D1 B1 B1 B1 D1 F1 D1 D1 D1 B1 D1 F1 F1 F1 D1 D1 D1 L1 D1 D1 
D1 R1 R1 R1 D1 L1 L1 L1 D1 D1 D1 R1 D1 F1 R1 R1 R1 F1 F1 F1 R1 F1 R1 
R1 R1 F1 F1 F1 R1 R1 R1 R1 D1 L1 D1 D1 D1 R1 D1 L1 L1 L1 D1 D1 D1 B1 
B1 B1 D1 F1 D1 D1 D1 B1 D1 F1 F1 F1 D1 D1 D1 F1 R1 R1 R1 F1 F1 F1 R1 
F1 R1 R1 R1 F1 F1 F1 R1 F1 D1 D1 D1 B1 B1 B1 D1 F1 F1 F1 D1 D1 D1 B1 
D1 F1 R1 R1 R1 F1 F1 F1 R1 F1 R1 R1 R1 F1 F1 F1 R1 F1 F1 F1 D1 B1 D1 
D1 D1 F1 D1 B1 B1 B1 D1 D1 D1 R1 D1 D1 D1 L1 L1 L1 D1 R1 R1 R1 D1 D1 
D1 L1 D1 R1 R1 R1 D1 L1 D1 D1 D1 R1 D1 L1 L1 L1 D1 D1 D1 R1 D1 D1 D1 
L1 L1 L1 D1 R1 R1 R1 D1 D1 D1 L1 D1 F1 F1 F1 D1 B1 D1 D1 D1 F1 D1 B1 
B1 B1 D1 D1 D1 L1 L1 L1 D1 R1 D1 D1 D1 L1 D1 R1 R1 R1 D1 D1 D1

동일한 이동이 함께 그룹화되어 있으면 이동 수를 상당히 줄일 수 있습니다. 따라서 다음과 같이 출력을 바꿀 수 있습니다

(c.gsub(/(.)\1*/){j=$&.size%4;$><<$1<<j<<' 'if j>0};o=z;s=t)if s>t
— 하워드
소스
멋지지만 때로는 내 컴퓨터에서 20 초 이상 걸리는 경우도 있습니다. 어떤 경우에는 48.7 초 만에 완료
— aditsu
@aditsu 네. 그러나 사용하는 루비 인터프리터에 따라 크게 달라집니다. 내 컴퓨터에서는 일반적으로 5 초 미만이 걸립니다.
— Howard
저는 현재 루비 1.9.3_p392를 사용하고 있습니다. 종종 5 초도 걸리지 않지만 "보통"이라고 말할 수 없습니다
— aditsu
이 입력을보십시오 :FU FR RU BR DB LD LU LB LF RD DF BU FRU BUR FDR DLB DFL LUB FUL DBR
— aditsu
하나의 요청 : 하나의 시퀀스 U1 U1 U1로 시퀀스를 통합 할 수 U3있습니까?
— primo
당사 사이트를 사용함과 동시에 당사의 쿠키 정책과 개인정보 보호정책을 읽고 이해하였음을 인정하는 것으로 간주합니다.
Licensed under cc by-sa 3.0 with attribution required.