Rubik küpünü çöz


38

Rubik küpünü (3 * 3 * 3) makul bir süre içinde ve hamle çözen en kısa programı yazınız (örneğin, makinenizde en fazla 5 saniye ve en az 1000 hamle).

Giriş biçiminde:

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

(bu özel girdi çözülmüş küpü temsil eder).
İlk 12 2 karakterli dizeler UF, UR, ... BL konumlarındaki (U = yukarı, F = ön, R = sağ, B = geri, L = sol, D = aşağı), sonra sonraki 8 3 karakterli dizeler UFR, URB, ... DBR konumlarındaki köşelerdir.

Çıktı bu formatta bir dizi hamle vermelidir:

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

D1 veya D + 'nın D (aşağı) yüzünü saat yönünde 90 derece döndürdüğü durumlarda, L2 L yüzünü 180 derece döndürürken, U3 veya U- U yüzünü saat yönünün tersine 90 derece döndürür.
Harfler büyük-küçük harf duyarlıdır ve boşluklar isteğe bağlıdır.

Örneğin, yukarıdaki çıkış aşağıdaki giriş için doğrudur:

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

Daha fazla ayrıntı için, lütfen Tomas Rokicki'nin küp yarışmasına bakınız , ancak puanlama normal bir kod golf sorunu gibi doğrudan dosya boyutuyla yapılır. Bir çevrimiçi test cihazı da dahil edilmiştir.

Başvuru için, önceden yazılmış en kısa çözüm, küp yarışmasının kazananları listesindeki son giriş.


Mizanpaj formatını görselleştirmek isteyenler için:

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  /
        +-------+-------+-------+

3
C / C ++ / Java / Perl / Python dışındaki diller kabul edilir mi?
Egor Skriptunoff

@EgorSkriptunoff Burada evet, dilediğin gibi kullan, küp çözme kütüphaneleri yok.
aditsu

Peki ya puanlama? Olağan kod-golf puanlaması (programdaki bayt) veya 2004 yarışmasında olduğu gibi karmaşık puanlama?
Egor Skriptunoff 12:13

2
@jdstankosky, bir diyagram ekledim.
Peter Taylor,

7
Çıkartmaları çıkartıp hareket ettirmemize izin var mı?
Iszi

Yanıtlar:


25

C ++ - 1123

Şu ana kadar kimse cevap vermediğinden, 2004'deki çözümümü basitleştirip golfe atmaya karar verdim. Hala soruda bahsettiğim en kısa olanın gerisinde.

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

Rastgele değil, ama aynı zamanda basit bir şekilde ilerlemiyor. Önce kenarları, sonra köşeleri çözer. Her adımda, çözülen parça sayısında bir iyileşme bulana kadar 4 algoritmaya ve basit yüz dönüşlerine (sırayla, rastgele değil) çeşitli kombinasyonları dener, sonra çözülene kadar tekrar eder. Tüm küp konumlarına çevrilmiş, kenarlar için 2 ve köşeler için 2 algoritması kullanır.

Şunun için örnek çıktı RU LF UB DR DL BL UL FU BD RF BR FD LDF LBD FUL RFD UFR RDB UBL RBU:

L2F3B2F3B1U3F1B3R2F3B1U3F1B3D2F2L3D2L1U2B1L1R3U2R1L3B1U2R1U2L1F1B3U2B1F3L1U2L3R1D3L1R3B2L3R1D3L1R3L3R1D3L1R3B2L3R1D3L1R3B3F1D3B1F3R2B3F1D3B1F3U2F3L3R1B3L1R3U2L3R1B3L1R3F1D2F1L1R3D2R1L3F1D2F3L2U1B1F3L2F1B3U1L2R3L1F3R1L3U2R3L1F3R1L3U1F2U1L1R3F2R1L3U1F2U3L3U3L1U3L3U2L1R1U1R3U1R1U2R3F3U3F1U3F3U2F1B1U1B3U1B1U2B3L1B3R3B1L3B3R1B1B3D3B1D3B3D2B1F1D1F3D1F1D2F3R1F3L3F1R3F3L1F1R3B3R1B3R3B2R1L1B1L3B1L1B2L3R1D3L3D1R3D3L1D1B3D3B1D3B3D2B1F1D1F3D1F1D2F3U3R3U1R3U3R2U1D1R1D3R1D1R2D3

(234 hamle, burada 0,3 saniye)


2
Ne biliyorsun ... saniyeler içinde başka bir cevap gönderildi :)
aditsu

Bu Ruby çözümünden daha uzun olsa da, sorun ölçütlerine "makul bir süre ve hamlede" daha uygun olduğunu düşünüyorum . Yine de ~ 50 hamle altında ortalama bir çözüm görmek istiyorum.
primo

2
@primo Thanks :) Orjinal kodum ortalama 50 hareketin üzerinde, 50 yaşın altında çünkü daha fazla (küp) algoritmaya veya Thistlethwaite metodu gibi farklı bir yaklaşıma ihtiyacınız olduğunu düşünüyorum. Bununla birlikte, verimlilik (hamle yapmadan) golf ile çok uyumlu değildir. Neyse, alternatif çözümler için Tomas Rokicki'nin yarışmasının kazananlarını inceleyin.
aditsu

23

Python 1166 bayt

Okunabilirlik uğruna önemli miktarda boşluk bırakılmıştır. Boyut Bu boşluk kaldırma ve çeşitli girinti düzeylerini değiştirdikten sonra ölçülür Tab, Tab Space, Tab Tabayrıca çok büyük ölçüde performansını etkilemiş herhangi golf kaçınılmalıdır vb ben.

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

Örnek kullanım:

$ 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

Bu, her adım için çözmek üzere bir IDA * araması kullanan Thistlethwaite Algoritmasının bir uygulamasıdır. Tüm sezgisel tabloların anında hesaplanması gerektiğinden, genellikle bir sezgisel bulguyu iki veya daha fazla eşit büyüklükte parçalara bölen birkaç ödün verildi. Bu, sezgisel tabloların hesaplanmasını yüzlerce kez daha hızlı yapar, ancak arama aşamasını yavaşlatır, genellikle sadece hafifçe, ancak ilk küp durumuna bağlı olarak önemli olabilir.

Değişken Endeksi

  • T - ana sezgisel tablo.
  • S- çözülmüş bir küp hali. Her bir parça, bir karakter olarak temsil edilen bir bit maskesi olarak saklanır. Çözülmüş bir oryantasyon vektörü sıfır vektör olarak tanımlanır.
  • I - çeşitli bükülmeler, arama alanından kaldırılmaları sırasına göre.
  • G- Değiştirilebilecek çiftler olarak saklanan büküm permütasyon grupları. Sıkıştırılmış dizedeki her bayt bir çift için kodlar. Her bükümün altı adet değişimi gerekir: kenar döngüsü için üç ve köşe döngüsü için üç. Sıkıştırılmış dize yalnızca yazdırılabilir ascii içerir (karakter 32 - 126).
  • M - G. tarafından verilen bir hareket gerçekleştiren bir işlev
  • N - kodlama amacıyla dört nesnenin permütasyonunu sayıya dönüştürür.
  • H - T'den hareket derinliği ararken kullanılan küp durumu için sezgisel değeri hesaplar.
  • P - algoritmanın tek bir aşamasının tek bir derinliğinde bir arama yapın.
  • s - giriş küpünün permütasyon durumu.
  • o - giriş küpünün oryantasyon vektörü.

Verim

Tomas Rokicki'nin veri setini kullanarak , bu komut dosyası ortalamada 472ms (i5-3330 CPU @ 3.0 Ghz, PyPy 1.9.0) ile çözme başına ortalama 16.02 büküm (maksimum 35). Minimum çözülme süresi 233ms idi, maksimum 2.97s, standart sapma 0.488. Yarışmadaki puanlama kurallarını kullanarak (beyaz boşluk sayılmaz, anahtar kelimeler ve tanımlayıcılar 870 uzunluğunda bir bayt olarak sayılır), toplam puan 13.549 olur.

Son 46 vaka için (rastgele durumlar), ortalama 721 ms süre ile çözme başına ortalama 30.83 büküm.


Thistlethwaite Algoritması Üzerine Notlar

Thistlethwaite Algoritmasının uygulanmasını denemek isteyen herkesin yararına , işte kısa bir açıklama.

Algoritma çok basit bir çözüm alanı azaltma prensibi üzerinde çalışır. Yani, küpü çözmek için bir bükülme alt kümesinin gerekli olmadığı bir duruma düşürün, daha küçük bir çözelti alanına düşürün ve sonra kalan sadece birkaç bükülmeyi kullanarak geri kalanı çözün.

Thistlethwaite başlangıçta <L,R,F,B,U,D><L,R,F,B,U2,D2><L,R,F2,B2,U2,D2>→ önerdi <L2,R2,F2,B2,U2,D2>. Bununla birlikte, girdi formatı göz önüne alındığında, önce <L,R,F2,B2,U,D>(çeyrek tur Fya da değil B), sonra <L2,R2,F2,B2,U,D>da yarı dönüş durumuna ulaşmadan önce azaltmanın daha kolay olduğunu düşünüyorum . Bunun neden olduğunu tam olarak açıklamak yerine, her bir devlet için kriterleri belirledikten sonra açık olacağını düşünüyorum.

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

Dönüşleri ortadan kaldırmak Fve Bçeyreklik yapmak için yalnızca kenarların doğru yönlendirilmesi gerekir. Gilles Roux'un sitesinde 'doğru' ve 'yanlış' yönelimin ne olduğu hakkında çok iyi bir açıklaması var , bu yüzden onu açıklayacağım. Ama esas olarak, (bu giriş biçimi öylesine condusive neden ve bu Fve Başağıdaki regex eşleşirse bir kenar cubie doğru yöne, eleme): [^RL][^UD]. Doğru yönlendirme tipik olarak a ile işaretlenir 0ve ile yanlış 1. Temel olarak Uve Detiketler, yüzlerde veya yüzeyin üzerinde veya herhangi bir veya kenar kübün kenarlarında görünmeyebilir Rveya bir veyaLUDFB çeyrek büküm.

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

Burada iki kriter. İlk olarak, tüm köşeler doğru yönlendirilmiş olması gerekir, ve ikinci, ara tabaka cubies için her ( FR, FL, BR, BL) orta tabakada bir yerde olması gerekir. Bir köşe yönü, giriş formatı verilen çok basit bir şekilde tanımlanmıştır: birinci pozisyon Uveya D. Örneğin URB, yönlendirmeye 0(doğru yönlendirilmiş), LDFyönlendirmeye 1ve LFUyönlendirmeye sahiptir 2.

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

Buradaki kriterler aşağıdaki gibidir: her yüz yalnızca yüzünden veya doğrudan karşısındaki yüzden çıkartmalar içerebilir. Örneğin, Uyüzünde sadece Uve Dçıkartmalar Rolabilir , yüzünde sadece Rve Lçıkartmalar Folabilir , yüzünde sadece Fve Bçıkartmalar olabilir, vb. Bunu sağlamanın en kolay yolu, her kenar parçasının içeride olup olmadığını kontrol etmektir. 'dilim' ve 'yörüngesindeki' her köşe parçası. Ek olarak, bir kenar köşesi paritesine dikkat etmek gerekiyor. Her ne kadar, sadece köşe paritesini kontrol ediyorsanız, kenar paritesi de garanti edilir ve bunun tersi de geçerlidir.

Bükülmeler oryantasyonu nasıl etkiler?

Uve Dkatlanmış kenar yönünü de köşe yönünü de etkiler. Oryantasyon vektörünü güncellemeden parçalar doğrudan değiştirilebilir.

Rve Lkatlanmış kenar yönünü etkilemez, ancak köşe yönünü etkiliyor. Eğer döngüsünü nasıl tanımladığına bağlı olarak, köşe yönündeki değişim ya olacak +1, +2, +1, +2ya +2, +1, +2, +1, bütün modülo 3. R2Ve L2bükülmelerin köşe oryantasyonunu etkilemeyeceğini unutmayın , olduğu gibi +1+2sıfır modulo 3olduğu gibi +2+1.

Fve Bhem kenar oryantasyonlarını hem de köşe oryantasyonlarını etkiler. Kenar yönelimleri haline +1, +1, +1, +1(mod 2) ve köşe yönlendirmeleri aynıdır Rve L. Bunu unutmayın F2ve B2ne kenar yönlerini ne de köşe yönlerini etkilediğini unutmayın .


Harika yazı. Kociemba'nın algoritmasını duydunuz mu?
miller

Sahibim. Prensip olarak, aynı algoritma, dört faz yerine, sadece iki taneye sahip: <L,R,F,B,U,D>-> <L2,R2,F2,B2,U,D>-> <I>. Bir küpü çözmek için en fazla 29 burgu gerektirir (Thistlethwaite'ler için 52 yerine), ancak 'anında' oluşturmak için pratik olmayan çok büyük arama tabloları gerektirir.
primo

@ P0W giriş formatı biraz kafa karıştırıcı, orada bir hata olabileceğinden şüpheleniyorum. Doğruladığım her durum bir çözümle sonuçlanır.
primo

@primo Eğer varsa, golfe ait olmayan kodun bağlantısını yayınlayabilir misiniz?
Bilow

12

Ruby, 742 karakter

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}

Yukarıdaki yakut kodu henüz tam olarak golf oynamamıştır. Kodu daha da iyileştirmek için hala olanaklar var (ama başlangıç ​​olarak zaten yeterli).

Küp katmanını katmana göre çözer, ancak belirli bir algoritma kullanmaz, bunun yerine küp çözülene kadar rasgele hareket dizileri gerçekleştirir.

Olasılıklı doğası nedeniyle, küpün çözülmesi bazen 5 saniyeden uzun sürebilir ve nadir durumlarda 1000'den fazla hareket alabilir.

Örnek çıktı ('RU LF UB DR DL BL UL FU BD RF BR FD LDF LBD FUL RFD UFR RDB UBL RBU' girişi için) 757 hamledir:

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 

Aynı hareketler bir arada gruplandırılmışsa, hareket sayısını önemli ölçüde azaltmak mümkündür. Bu nedenle, bir çıktı gibi yerini alabilir

(c.gsub(/(.)\1*/){j=$&.size%4;$><<$1<<j<<' 'if j>0};o=z;s=t)if s>t

Güzel, ama bazen bilgisayarımda 20 saniyeden fazla zaman alıyor, bir durumda 48.7 saniyede
bitiyor

@aditsu Evet. Ancak, hangi yakut tercümanı kullandığınıza da bağlıdır. Makinemde genellikle 5 saniyeden az sürer.
Howard

Şu anda yakut 1.9.3_p392 kullanıyorum , genellikle 5 saniyeden daha az sürüyor ancak "genellikle"
diyemiyorum

Bu girişi deneyin:FU FR RU BR DB LD LU LB LF RD DF BU FRU BUR FDR DLB DFL LUB FUL DBR
aditsu

Bir istek: gibi dizileri U1 U1 U1tek bir konsolidasyonda birleştirir misiniz U3?
primo
Sitemizi kullandığınızda şunları okuyup anladığınızı kabul etmiş olursunuz: Çerez Politikası ve Gizlilik Politikası.
Licensed under cc by-sa 3.0 with attribution required.