आपका काम चालों का एक यादृच्छिक अनुक्रम बनाना है, जिसका उपयोग एक रूबिक क्यूब को घसीटने के लिए किया जा सकता है। इस तरह की हाथापाई ठीक 25 चालों से बनी होती है। प्रत्येक चाल में अक्षर के UDRLFBवैकल्पिक रूप से एक प्रत्यय होता है '2।

^{इस नोटेशन को सिंगमास्टर नोटेशन कहा जाता है। UDRLFB6 चेहरों में से एक का प्रतिनिधित्व करता है और वैकल्पिक प्रत्यय '2मोड़ कोण का प्रतिनिधित्व करता है। यह जानकारी किसी भी तरह से कार्य को हल करने के लिए आवश्यक नहीं है।}

आश्वस्त करने के लिए, कि स्क्रैम्बल 'अच्छी गुणवत्ता' के हैं, निम्नलिखित दो नियमों को लागू करना है:

लगातार दो चालों में समान अक्षर नहीं होना चाहिए। यह लगातार चलता रहता है पर रोक लगाई UU, DD, RR, LL, FFऔर BBऔर उनके सभी संयोजनों की तरह वैकल्पिक प्रत्ययों का उपयोग कर U2Uया U'U'।

^{इन चाल जोड़ी को प्रतिबंधित कर दिया जाता है, क्योंकि वे आसानी से 1 या 0 चालों तक कम हो सकते हैं। U2Uजैसा प्रभाव है U', R'Rवैसा ही प्रभाव ।}
लगातार तीन चालें एक ही अक्षर समूह की नहीं होनी चाहिए। पत्र समूह हैं UD, RLऔर FB। यह नियम अतिरिक्त लगातार चलता रहता है पर रोक लगाई UDU, DUD, RLR, LRL, FBF, BFBऔर उनके सभी संयोजनों की तरह वैकल्पिक प्रत्ययों का उपयोग कर U2DU, RL'Rया B2FB'।

^{समूह अपनी चाल अक्ष द्वारा चेहरों को क्रमबद्ध करते हैं। Uऔर Dएक ही समूह में हैं, क्योंकि दोनों एक ही धुरी पर घूमते हैं। इसलिए एक Uचाल Dचेहरे के टुकड़ों को प्रभावित नहीं करती है , और एक Dचाल Uचेहरे के टुकड़ों को प्रभावित नहीं करती है । इसलिए दो चालों का आदान-प्रदान किया जा सकता है, UDUजैसा ही प्रभाव पड़ता है UUD, और इसे कम किया जा सकता है U2D।}

चुनौती

एक स्क्रिप्ट या एक फ़ंक्शन लिखें, जो एक यादृच्छिक हाथापाई उत्पन्न करता है। कोई इनपुट नहीं है। स्क्रिप्ट / फ़ंक्शन को एक स्थान से अलग या अलग किए बिना 25 चालों को प्रिंट करना होगा या संवाददाता स्ट्रिंग को वापस करना होगा।

आपके कार्यक्रम को प्रत्येक एकल स्क्रैम्बल बनाने में सक्षम होना चाहिए, जो ऊपर दिए गए नियमों को पूरा करता है। बेशक, यादृच्छिक संख्या जनरेटर सच यादृच्छिक है, और छद्म यादृच्छिक नहीं है।

यह कोड-गोल्फ है। सबसे छोटा कोड ( बाइट्स में गिना गया ) जीतता है।

उदाहरण आउटपुट:

स्क्रिप्ट / फ़ंक्शन को 3 बार कॉल करना कुछ इस तरह प्रिंट / वापस करना चाहिए:

R'B2R2F2R2FB'R2DR2ULFB2RB'U2B'FL'BR'U'RB'
U'DBR'B2U'B'U'RUF'B'RDR2U'B'LR'B'F2D2UF2L'
BR2F'B'R'D'R'U2B'F2D2R'F2D'F'D2R2B'L2R'UB'R2L'D

यदि आप प्रत्येक स्थान पर चालों को अलग करते हैं:

R2 L' F2 U2 D' R2 L2 F L' D2 U R B D' U2 L B2 L U B2 D U2 R' D2 U'
B R D2 F U2 B' R2 F2 B' U' L' R2 B U2 R' D B' F' U2 R' B' L R D2 R2
B2 R2 U D' B R D' R L2 D2 L2 R B2 F U' F2 B2 U' F U' D F R2 U2 B'

ध्यान दें, कि इन सभी आउटपुटों में 25 चालें होती हैं, लेकिन वैकल्पिक प्रत्ययों के कारण इसकी लंबाई अलग-अलग होती है। यह एक अंतरिक्ष मुद्रित करने के लिए अनुमति नहीं है जब या तो 2या 'प्रत्यय के रूप में उपयोग हैं। आप मुद्रित करने के लिए है L2UR2F'R'U2या L2 U R2 F' R' U2। L2U R2F'R'U2अनुमति नहीं है।

— Jakube
स्रोत

क्या आपका मतलब UR 2अनुमति नहीं है? मुझे अनुमति दी U R2 जानी चाहिए, मुझे लगता है, क्योंकि चालों के बीच रिक्त स्थान समझ में आता है।

— mbomb007

@ mbomb007 मेरा मतलब सामान की तरह है L2U R2F'R'U2। Uकोई वैकल्पिक प्रत्यय नहीं है और इसलिए स्थान नहीं होना चाहिए। एक स्थान वैकल्पिक प्रत्यय के लिए एक प्रतिस्थापन नहीं होना चाहिए।

— जकुबे

यदि हर चाल के बीच रिक्त स्थान हों तो क्या होगा? क्या हम आउटपुट कर सकते हैं U F2 L D2 R'..., उदाहरण के लिए? इस मामले में, एक अतिरिक्त स्थान नहीं है, जो मुझे लगता है कि आपके नियम के अनुसार ठीक होना चाहिए।

— mbomb007

@ mbomb007 हां, मैं इसे विवरण में डालूंगा।

— जकुबे

पत्र से पहले 2 नहीं है? OO

— ऑलिवर नी

6

सीजेएम, 47 45 बाइट्स

यह समाधान एक दृष्टिकोण का उपयोग करता है जो अब तक पोस्ट किए गए किसी भी अन्य से अलग है। यह उपलब्ध चाल सूची उत्पन्न करने के लिए CJam की संक्षिप्त सूची संचालन का लाभ उठाता है और प्रत्येक पुनरावृति यादृच्छिक पर एक का चयन करता है। संशोधक बस स्वतंत्र रूप से उत्पन्न होते हैं।

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

{BA^2/6,_B-?A:B-mr0=:A"UDRLFB"=3mr[L2'']=}25*

व्याख्या

{               "Loop...";
  BA^2/           "If the two previous moves were not from the same group, ...";
  6,              "... then produce the available move list [0 1 2 3 4 5], ...";
  _B-             "... else produce the available move list [0 1 2 3 4 5] with
                   the second previous move removed";
  ?
  A:B             "Save the previous move as the second previous move";
  -               "Remove the previous move from the available move list";
  mr0=            "Randomly select an available move";
  :A              "Save this move as the previous move";
  "UDRLFB"=       "Map this move to its character (implicitly printed)";
  3mr[L2'']=      "Randomly select a modifier (implicitly printed)";
}25*            "... 25 times";

— Runer112
स्रोत

9

सी, 129

f(){int i,n,m,r,s,t;for(i=26;i--;i<25&&printf("%c%c","URFDLB"[s%6],"'2"[r%3])){for(n=m,t=1;t;t=m*n==9)m=(r=rand()%15)/3+1;s+=m;}}

आंतरिक लूप mउस सीमा का एक मान उत्पन्न करता है 1..5जो जब sमॉडुलो 6 में जोड़ा और लिया जाता है, तो यह सुनिश्चित करता है कि लगातार दो चालें क्यूब के एक ही तरफ न हों। का पुराना मान mसंग्रहीत किया जाता है nऔर परीक्षण m*n==9यह सुनिश्चित करता है कि मान m= 3 एक पंक्ति में दो बार उत्पन्न नहीं होता है (इसलिए विपरीत चेहरों को एक पंक्ति में दो बार नहीं उठाया जा सकता है; स्ट्रिंग में चेहरों के क्रम पर ध्यान दें।)

के कम से कम महत्वपूर्ण हिस्सा rजो प्रत्यय (तय करने के लिए प्रयोग किया जाता है ', 2उपयोग करने के लिए या नल), के अंत में नल केरेक्टर का लाभ लेने के "'2"।

बाहरी लूप 26 बार चलता है। पहली बार, Uकभी नहीं उठाया जा सकता है, इसलिए printfपहली यात्रा के लिए दबा दिया जाता है।

परीक्षण कार्यक्रम में असम्बद्ध कोड

अनगोल्ड कोड स्पष्टता के लिए प्रत्येक चाल के बीच एक स्थान रखता है (गोल्फ कोड ऐसा नहीं करता है, ताकि एक बाइट को बचाया जा सके।) इसके अलावा गोल्फ कोड एक अर्धविराम printfको forब्रैकेट के भीतर स्थानांतरित करके बचाता है ।

f(){
  int i,n,m,r,s,t;
  for(i=26;i--;){
    for(n=m,t=1;t;t=m*n==9)m=(r=rand()%15)/3+1;
    s+=m;
    i<25&&printf("%c%c ","URFDLB"[s%6],"'2"[r%3]);
  }
}

main(){
  int j;
  srand(time(0));
  for(j=0;j<5;j++)f(), puts("");
}

विशिष्ट उत्पादन

U' B D2 B' R' L F' D2 B D2 B2 R' B2 U D2 F' R U R' L B' L R2 B2 F'
U B U B F L2 D2 B' U' L B L R' D B U' D R D' B' F2 D' B D R
L D F2 B2 R' U F B' D2 L U R' L' U2 F' R F D U2 B L' B' U L2 F'
R2 B' F2 R2 L2 F' U2 L U' B' F R' D' F2 D F' L2 U2 R' D' B2 D F R2 L'
U2 F2 B2 D' F D F R L2 U' B D2 L' R D R F2 R' F2 U2 D R' D2 L F2

— स्तर नदी सेंट
स्रोत

124 बाइट्स

— एमडी एक्सएफ

118 बाइट्स

— सीलिंगकैट

4

Pyth, 65 66

मैंने पाइथ में कभी भी गोल्फ नहीं खेला है, शायद एक या दो कार्यक्रम लिखे हैं। यह मूल रूप से @ स्टीवेवरिल का समाधान है जिसका अनुवाद पायथ में किया गया है। सुधार के सुझावों का स्वागत है।

अपडेट: स्क्रैम्बल्स बनाने के लिए 1 बाइट जोड़ा गया है U। हो सकता है कि सी समाधान यह काम करने के लिए अपरिभाषित व्यवहार पर निर्भर है ...

=YO6V25JZK1WK=GO15=Z/+3G3=Kq9*ZJ)~YZpd+@"URFDLB"%Y6?@"'2"%G3>2%G3k

मेरा मानना है कि इसे कम असाइनमेंट के साथ किया जाना चाहिए, लेकिन इसके लिए मुझे एल्गोरिथ्म को बहुत संशोधित करना होगा। (खैर, कोशिश कर सकते हैं।)

यहाँ C कोड के आधार पर स्पष्टीकरण दिया गया है:

=YO6           s = random.choice(range(6))
V25            for i in range(25):
  JZ               n = m
  K1               t = 1
  WK               while t:
    =GO15              r = random.choice(range(15))
    =Z/+3G3            m = (r + 3) / 3
    =Kq9*ZJ            t = 9 == m * n
  )
  ~YZ              s += m
  pd               print(..., end = " ")
  +                ... + ...
  @"URFDLB"%Y6     "URFDLB"[s % 6]
  ?@"'2"%G3>2%G3k  "'2"[G % 3] if 2 > G % 3 else ""

— PurkkaKoodari
स्रोत

चर Yऔर स्विच Z। Z0 के साथ पहले से चिह्नित है, इसलिए आप पहले 3 वर्णों को बचाते हैं।

— जकुबे

@Jakube लेकिन फिर मुझे n = m(3 स्पष्टीकरण लाइन) सेट करने की आवश्यकता है , जिसका मतलब n = 0पहली बार होना चाहिए , जिसके बदले में Y0.

— PurkkaKoodari

Yएक खाली सूची के साथ preinitialized है []। और मुझे नहीं लगता कि nपहली यात्रा में मामलों का मूल्य ।

— जकुबे

Btw, आपका कोड स्क्रैम्बल का उत्पादन नहीं करता है जो इसके साथ शुरू होता है U।

— जकुबे

@ जकुब धन्यवाद, निश्चित।

— पुरकाकूदरी

4

जावास्क्रिप्ट (ईएस 6) 175 178 204

3 बाइट्स कम संपादित करें , 1 कोड को बदलकर और 2 बाइट्स के तरीके को बदलकर गिना जाता है (गिनती नहीं F=)

पुनरावृत्ति से बचने के लिए कोड @stevemiller से लिया गया है। पत्र समूहों के प्रबंधन का उनका तरीका और भी बेहतर है, लेकिन मैं इसे चोरी नहीं करने जा रहा हूं।

बोनस: आप वैकल्पिक रूप से चाल की संख्या निर्दिष्ट कर सकते हैं।

(n=25,R=n=>Math.random()*n|0)=>(r=>{for(N=_=>'UDRLFB'[(r-=~R(5))%6],b=N(a=N(s=''));n;~(a+b+c).search('^([UD]*|[RL]*|[FB]*)$')?0:s+=(--n,a=b,b=c)+["","'",2][R(3)])c=N()})(0)||s

कम गोल्फ वाला

(n = 25) => 
{
  R = n => Math.random()*n | 0;
  N = _ => 'UDRLFB'[(r += 1+R(5)) % 6];
  r = 0;
  b = N();
  a = N();
  for(s = '' ; n; )
     c = N(),
     ~(a+b+c).search('^([UD]*|[RL]*|[FB]*)$')
       ? 0
       : s += (--n, a=b, b=c) + ["","'",2][R(3)];
  return s
}

परीक्षा

var F=
(n=25,R=n=>Math.random()*n|0)=>(r=>{for(N=_=>'UDRLFB'[(r-=~R(5))%6],b=N(a=N(s=''));n;~(a+b+c).search('^([UD]*|[RL]*|[FB]*)$')?0:s+=(--n,a=b,b=c)+["","'",2][R(3)])c=N()})(0)||s

function go() {
  console.log(F(+M.value))
}

go()

Moves <input type=number min=1 id=M value=25 max=999>
<button onclick='go()'>Test</button>

स्निपेट का विस्तार करें

— edc65
स्रोत

2

जावास्क्रिप्ट - 112

for(c=b=j=25,r=Math.random;j;c+b-5|c-m&&b-m?document.write("URFBLD"[j--,c=b,b=m]+" 2'"[0|r()*3]+" "):0)m=0|r()*6

— मामा फन रोल
स्रोत

2

जावा 8, 189 183 बाइट्स

v->{for(int i=26,n,m=0,r=0,s=0,t;i-->0;){for(n=m,t=1;t>0;t=m*n==9?1:0)m=(r=(int)(Math.random()*15))/3+1;s+=m;if(i<25)System.out.print("URFDLB".charAt(s%6)+(r%3<1?"'":r%3<2?"2":""));}}

पोर्ट @LevelRiverSt के सी उत्तर । मैंने खुद कुछ चीजों की कोशिश की, लेकिन यह मेरे पास जितना था उससे कम था।

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

— केविन क्रूज़सेन
स्रोत

2

रूबी , 116 107 105 95 बाइट्स

->{(0..r=l=m=24).map{m=rand 6while l==m||r/2==l/2&&l/2==m/2;r=l;l=m;'RLFBUD'[m]+" '2"[rand 3]}}

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

— आसोन तुहिद
स्रोत

1

क्लोजर, 223 बाइट्स

(let[R(range)F(fn[f p c](apply concat(filter f(partition-by p c))))](apply str(map str(take 25(F(fn[p](<(count p)3))(zipmap"UDLF""1122")(F(fn[p](=(count p)1))int(for[_ R](rand-nth"UDRLFB")))))(for[_ R](rand-nth[""\'\2])))))

यह "अनुक्रम -> विभाजन-द्वारा -> फ़िल्टर -> कंकरीट" पैटर्न पर बहुत निर्भर करता है, इसका उपयोग चेहरों के "अवैध" दृश्यों को फ़िल्टर करने के लिए किया जाता है। इस seq को एक यादृच्छिक पोस्टफिक्स (खाली स्ट्रिंग सहित) के साथ एक साथ स्ट्रिंग करने के लिए मैप किया जाता है।

आरंभिक बिंदु:

(->> (for[_(range)](rand-nth"UDRLFB"))
     (partition-by int)           ; "identity" would be the correct fn to use here
     (filter(fn[p](=(count p)1))) ; Only one identical value in partition
     (apply concat)
     (partition-by(zipmap"UDLF""1122")) ; R & B are in the implicit nil group
     (filter(fn[p](<(count p)3)))       ; Only 1 or 2 consecutive faces from a group
     (apply concat)
     (take 25))

— NikoNyrh
स्रोत

रूबिक के क्यूब स्क्रबल्स

चुनौती

उदाहरण आउटपुट:

सीजेएम, 47 45 बाइट्स

व्याख्या

सी, 129

Pyth, 65 66

जावास्क्रिप्ट (ईएस 6) 175 178 204

जावास्क्रिप्ट - 112

जावा 8, 189 183 बाइट्स

रूबी , 116 107 105 95 बाइट्स

क्लोजर, 223 बाइट्स