रूबिक क्यूब पर पहचान अनुक्रम

Question

मूव सीक्वेंस रुबिक क्यूब पर मूव्स (टर्न) का एक क्रम है (नोटेशन नीचे देखें)। खाली चाल अनुक्रम के अलावा, कई अन्य चाल क्रम हैं, जिनका घन पर कोई प्रभाव नहीं है। हम इन चाल अनुक्रमों को पहचान अनुक्रम कहते हैं।

इन पहचान अनुक्रमों में से कुछ निर्धारित करने के लिए स्पष्ट हैं, जैसे U2 R R' U2या U D2 U' D2। पहले एक में, दो यादृच्छिक चालें की जाती हैं U2 Rऔर बाद में तुरंत पूर्ववत किया जाता है R' U2। दूसरा समान है। पहले दो यादृच्छिक चालें U D2और बाद में वे पूर्ववत हैं, लेकिन उलटे क्रम में U' D2। यह केवल काम करता है, क्योंकि चाल Uकेवल ऊपरी परत के D2टुकड़ों पर प्रभाव डालती है और चाल केवल निचली परत के टुकड़ों पर प्रभाव डालती है। आप इन दो चाल अनुक्रमों का एक दृश्य देख सकते हैं।

अन्य पहचान अनुक्रम स्पष्ट नहीं हो सकते हैं। उदाहरण के लिए अनुक्रम R' U' R' F' U F U' R' F R F' U' R U2 R। यह बहुत लंबा है, लेकिन घन पर भी इसका कोई प्रभाव नहीं है।

मूवमेंट नोटेशन

एक चाल घन के छह चेहरों में से एक की एक परत की बारी का वर्णन करती है। एक चाल में एक अक्षर होता है जो बारी के कोण का प्रतिनिधित्व करते हुए एक वैकल्पिक प्रत्यय के साथ चेहरे का प्रतिनिधित्व करता है।

अक्षर और उनके संगत चेहरे U हैं (ऊपर - ऊपर की ओर का सामना करना पड़ रहा है), D (नीचे - नीचे की ओर का सामना करना पड़ रहा है), R (दाएं - दाईं ओर का सामना करना पड़ रहा है), L (बाएं - बाईं ओर का सामना करना पड़ रहा है) , एफ (सामने - आपके सामने की तरफ) और बी (पीछे - आपके सामने की तरफ का भाग)।

यदि कोई प्रत्यय नहीं है, तो चेहरे को 90-डिग्री दक्षिणावर्त घुमाया जाता 'है, प्रत्यय का अर्थ है, चेहरा 90-डिग्री वामावर्त मुड़ता है, और प्रत्यय का 2अर्थ है, चेहरा 180-डिग्री दक्षिणावर्त हो गया है।

यह आपको नोटेशन के साथ कोई समस्या है, बस http://alg.cubing.net का उपयोग करें , जहां आप इस तरह के चाल अनुक्रमों की कल्पना कर सकते हैं।

चुनौती

आपका कार्य एक कार्यक्रम लिखना है, जो यह निर्धारित करता है कि एक चाल अनुक्रम एक पहचान है या नहीं।

आप एक पूर्ण कार्यक्रम या एक समारोह लिख सकते हैं। इसे इनपुट (STDIN, कमांड-लाइन तर्क, प्रॉम्प्ट या फ़ंक्शन तर्क के माध्यम से) और आउटपुट (वापसी मान या STDOUT के माध्यम से) बूलियन मान या संबंधित पूर्णांक के रूप में एक स्ट्रिंग अनुक्रम प्राप्त होता है (इनपुट्स स्पेस से अलग होते हैं)। सत्य - १ - पहचान अनुक्रम / मिथ्या - ० - पहचान क्रम नहीं)।

यदि आप प्रत्यय 'अपनी प्रोग्रामिंग भाषा में समस्याएं पैदा करते हैं, तो आप एक अलग प्रतीक का उपयोग कर सकते हैं, लेकिन अंक में नहीं। R F2 U3अनुमति नहीं है।

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

परीक्षण के मामलों

"" -> True
"U2 R R' U2" -> True
"U D2 U' D2" -> True
"U2 R U2 R'" -> False
"R' U' R' F' U F U' R' F R F' U' R U2 R" -> True
"L'" -> False
"B B2 B' B2" -> True
"D D2 D'" -> False
"R F' D2 U B' F2 B' U2 D2 F2 B2 U F R'" -> True
"D2 U' R2 U F2 D2 U' R2 U' B' L2 R' B' D2 U B2 L' D' R2" -> False
"R U R' U' R' F R2 U' R' U' R U R' F' R2 U R2 U' R2 U' D R2 U' R2 U R2 D'" -> True
"R U R' U' R' F R2 U' R' U' R U R' F' R2 U' R2 U R2 U' D R2 U' R2 U R2 D'" -> False
"B2 F2 U' F2 U R2 F2 U2 B D' R' D' R2 D' F2 U' F U R2 U R B D B D2 L2 D' F2 U D' R' D B R2 D2 F2 R' F2 D2" -> True
"R U2 R' U R' U2 R U2 R U R' U' R' U R U2" -> False
"U F B' R' U F' R U' F' B L U' F L'" -> False
"R2 U' R' U' R U R U R U' R" -> False
"R' F R' B2 R F' R' B2 R2" -> False

Comments

इसमें गलत क्या है R F2 U3?

— जॉन ड्वोरक

मैं बस यह सुनिश्चित करना चाहता हूं, कि हर किसी के पास एक ही शर्त हो। अगर मैं अनुमति देता U3, तो आप केवल एक अंक में प्रत्यय डाल सकते थे।

— जकुबे

मैं टी-टॉप, बी-बॉटम और पी-पोस्टीरियर (बैक) का उपयोग करने वाले नोटेशन के लिए अधिक अभ्यस्त हूं। लोगों को शायद सिक्वेंस देखकर ही अच्छा लगा R2 D2।

— mbomb007

@ mbomb007 मैं शीर्ष के लिए टी को समझ सकता हूं, लेकिन मैंने पी को कभी पीछे नहीं देखा है और मुझे इसका अर्थ समझ में नहीं आएगा कि क्या यह आपकी टिप्पणी के लिए नहीं था ...

— जॉन ड्वोरक

@ mbomb007 मैंने वह नोटेशन भी देखा है, लेकिन यह मूल सिंगमास्टर नोटेशन जितना सामान्य या पुराना नहीं है, और मुझे नहीं पता कि लोग मूल के साथ गड़बड़ क्यों करना चाहते हैं। हालांकि डेविड सिंगमास्टर (जहां तक ​​मुझे पता है) ने इसका उल्लेख नहीं किया है, मैंने देखा है कि सभी चेहरे पूरी तरह से सुसंगत हैं और यदि कोई स्थान के बजाय दिशाओं के रूप में माना जाता है तो कोई संघर्ष नहीं है। That is F(orward), B(ackward), L(eft), R(ight), U(p), D(own)

— लेवल रिवर सेंट

Answer 1

हास्केल, 263 261 247 243 वर्ण

c[x]=[x]
c(x:"2")=[x,x]
c(x:_)=[x,x,x]
s!a@[x,y,z]=case s of
 'R'|x>0->[x,-z,y]
 'B'|y>0->[z,y,-x]
 'U'|z>0->[-y,x,z]
 'L'|x<0->[x,z,-y]
 'F'|y<0->[-z,y,x]
 'D'|z<0->[y,-x,z]
 _->a
r=[-2..2]
i=mapM id[r,r,r]
f w=i==foldr(map.(!))i(c=<<words w)

बल्कि सीधा एल्गोरिदम; प्रत्येक क्यूबलेट 1,2,4 या 8 चंक्स से बना होता है, जो अपनी स्थिति और अभिविन्यास को एन्कोडिंग करता है; प्रति छोर क्यूबलेट में 4 विखंडू, 8 प्रति कोने क्यूबलेट, 7 क्यूबलेट स्थिर हैं।

c c इनपुट के प्रत्येक शब्द को CW के एक अनुक्रम में बदल देता है, और !प्रत्येक चंक को एक मोड़ के अनुसार भेजता है। iहै मैं dentity स्थिति। fमुख्य च एकता है।

मैं cहोमप फ़ंक्शन से बहुत खुश नहीं हूं , लेकिन मैं इसे छोटा करने का कोई तरीका नहीं खोज सकता (@Nimi ने, हालांकि)

Comments

कैसे के बारे में c(x:"2")=[x,x]और c(x:_)=[x,x,x]। 2 बाइट बचाता है।

— निमि

यदि आप उपयोग करते हैं i=sequence[s,s,s], और सभी टुपल्स को सूचियों में बदलते हैं (यानी: (x,y,z)बन जाता है [x,y,z]) - यह ~ 9 वर्णों को बचाएगा। इसमें डालने से 4 और बचते हैं। _मामले को छोड़ने से !एक और 11. बचाता है

— MtnViewMark

@MtnViewMark किया और सुधार i, धन्यवाद। निश्चित नहीं है कि आपको इनलाइनिंग से क्या मतलब है i- कृपया ध्यान दें कि यह परिभाषा में दो बार दिखाई देता है f। निश्चित नहीं है कि आप _मामले को छोड़ने का क्या मतलब है - या तो _->aपूरी तरह से छोड़ने या इसे शीर्ष पर ले जाने के लिए एक गैर-थकाऊ पैटर्न अपवाद है, और इसे शीर्ष पर ले जाना किसी भी वर्ण को नहीं बचाता है। मैंने हालांकि 5 पात्रों को बचाने का प्रबंधन किया।

— जॉन ड्वोरक

महान समाधान। मैंने सभी परीक्षण मामलों की जाँच की।

— जकुबे

फिर, आपके समाधान के लिए बधाई। चूँकि आपने सबसे छोटा कोड प्रस्तुत किया था, इसलिए आपको 100 की कीमत का इनाम मिलता है।

— जक्यूब

Answer 2

मूल रूप से , 6 4 बाइट्स

¶=8%

मैं जीतता हूं: पी

¶=8%
¶     read a string, evaluate as Cubically code
 =8   set notepad to (notepad == 8th face)
   %  print notepad

नोटपैड शून्य पर आरंभीकृत होता है। 8 वें "चेहरे" में 1 होता है अगर घन अनसुलझा हो और 0 अन्यथा।

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

Comments

एक दिलचस्प भाषा लगती है। लेकिन क्योंकि भाषा को चुनौती दी गई पोस्ट के बाद बनाया गया था, यह जीतने के लिए योग्य नहीं है।

— जकूबे

@ जाकुब मैं मानता हूं कि इसे स्वीकार नहीं किया जाना चाहिए, सिर्फ इस तथ्य के कारण कि यह रूबिक के क्यूब बिल्डिंस के साथ एक भाषा है जो चुनौती के बाद इतनी देर से पोस्ट की गई थी और इसलिए अन्य उत्तरों को पूरी तरह से नष्ट कर रही है। लेकिन यह मेटा के अनुसार जीतने के लिए तकनीकी रूप से योग्य है (गैर-प्रतिस्पर्धा नियम को कुछ हद तक रद्द कर दिया गया था)।

— एमडी एक्सएफ

Answer 3

जे - 232, 220, 381, 315 296 बाइट्स

यह समाधान सभी परिचालनों को चेहरे के क्रमपरिवर्तन के रूप में बताता है और इस तथ्य के आधार पर काम करता है कि सभी चेहरे ट्विस्ट वास्तव में एक ही हैं, पूरे घन के रोटेशन के तहत।

संपादित करें : कुछ और गोल्फिंग

f=:+/~6&*
r=:4 :'y f&.>(]{^:x~)&.C.;/i.2 4'"0
t=:((r~0),_4<\44#.inv 1478253772705907911x)&C.&.
Y=:(C.(,0 2 r 4 5),;/4 f&i.8)&{^:t
X=:((,1 1 0 2 r 2 4 3 1)C.C.;/0 4 2 5 f i.8)&{^:t
61".@A."1'=: ',"#~6 3$'D0XR1YF1XU2YB3XL3Y'
T=:[:(_2".@}.'(i.48)-:'&(,,[))[:(,'^:',])/&.>@|.&.;:[:''''&=@{.`]},:&'3'

पिछले कोशिश करता अलावा, इस करता खाते में कोने रोटेशन ले।

fसिर्फ एक सहायक कार्य है। rएक चेहरे के रोटेशन करता है। एक चेहरा इस प्रकार है:

1. 6 के चरणों में सभी कोनों
2. छह के चरणों में सभी किनारों

इस आदेश में घुमाव और मोड़ की एन्कोडिंग की सुविधा है। tएक क्रिया विशेषण है जो एक निश्चित घन रोटेशन के तहत चेहरे को घुमाता है, चेहरे का चयन करता है।

Xऔर Yक्रियाविशेषण हैं जो बाएं तर्क के रूप में पूरे घन की दिशा में संख्या को लेते हैं।

अगली पंक्ति सभी घुमावों को परिभाषित करती है: रोटेशन के प्रति 3 वर्ण: नाम, घुमावों की संख्या और दिशा।

अंतिम पंक्ति परीक्षण क्रिया को परिभाषित करती है T, 3 और 'पावर संकेतन को परिवर्तित करते हुए , ऑपरेशन के क्रम को प्रवाहित करते हुए परीक्षण वेक्टर को जोड़ते हुए और पूरी तरह से एक्साइट करते हुए।

अनुरोध पर अधिक जानकारी।

tests =: (] ;. _2) 0 : 0

 U2 R R' U2
 U D2 U' D2
 U2 R2 R'
 R' U' R' F' U F U' R' F R F' U' R U2 R
 L'
 B B2 B' B2
 D D2 D'
 R F' D2 U B' F2 B' U2 D2 F2 B2 U F R'
 D2 U' R2 U F2 D2 U' R2 U' B' L2 R' B' D2 U B2 L' D' R2
 R U R' U' R' F R2 U' R' U' R U R' F' R2 U R2 U' R2 U' D R2 U' R2 U R2 D'
 R U R' U' R' F R2 U' R' U' R U R' F' R2 U' R2 U R2 U' D R2 U' R2 U R2 D'
 B2 F2 U' F2 U R2 F2 U2 B D' R' D' R2 D' F2 U' F U R2 U R B D B D2 L2 D' F2 U D' R' D B R2 D2 F2 R' F2 D2
 R U2 R' U R' U2 R U2 R U R' U' R' U R U2
 U F B' R' U F' R U' F' B L U' F L'
 R2 U' R' U' R U R U R U' R
 R' F R' B2 R F' R' B2 R2
)
res =: 1 1 1 0 1 0 1 0 1 0 1 0 1 0 0 0 0
res ([,],:=) T"1 tests NB. passes all tests.
1 1 1 0 1 0 1 0 1 0 1 0 1 0 0 0 0
1 1 1 0 1 0 1 0 1 0 1 0 1 0 0 0 0
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

NB. some handy display methods:
dispOrig=: (". ;._2) 0 :0
   _   _   _   5  29  11   _   _   _   _   _   _
   _   _   _  47  _1  35   _   _   _   _   _   _
   _   _   _  23  41  17   _   _   _   _   _   _
   3  27   9   0  24   6   1  25   7   2  26   8
  45  _3  33  42  _6  30  43  _5  31  44  _4  32
  21  39  15  18  36  12  19  37  13  20  38  14
   _   _   _   4  28  10   _   _   _   _   _   _
   _   _   _  46  _2  34   _   _   _   _   _   _
   _   _   _  22  40  16   _   _   _   _   _   _
)
ind =: dispOrig i.&, i. 48 NB. indices of i.48 in the original display

disp =: (9 12$(,dispOrig) ind}~ ])
changed =: 1 : '(u ~:&disp ]) i.48' NB. use to debug permutation verbs: L ch
vch =: 1 :'disp  ((]+_*=) u)'
NB. viewmat integration RGB
cm =: 255 * 1 0 0 , 1 1 1, 0 1 0, 1 1 0, 1 0.5 0, 0 0 1,: 0 0 0 NB. colormap
NB. use as:  "cube i. 48" for seeing a nice folded out cube.
cube =: cm viewmat (>&7 + >&15 + >&23 + >&31 + >& 39 + >&47)@|@disp@]

Comments

"जैसा कि मेरे परीक्षा परिणाम दिए गए लोगों के साथ मेल नहीं खाते ..." के रूप में, आपके समाधान काम नहीं करता है? मैं इसे तब पोस्ट नहीं करूंगा ...

— जॉन ड्वोरक

आप सही हे। अब निश्चित कर दिया।

— jpjacobs

मैंने 4 अतिरिक्त परीक्षण मामले जोड़े। उनमें से दो अभी भी गलत परिणाम लौटाते हैं। ऐसा लगता है कि आप कोनों के उन्मुखीकरण की उपेक्षा करते हैं।

— जकुबे

@jpjacobs अब सवाल पर 100 प्रतिनिधि इनाम है। अपने कोड को सही करना चाहते हैं?

— जकुबे

वोइला, किया। अब बस इसे कम कर रहे हैं।

— jpjacobs

Answer 4

पायथन 3: 280 चार्ट

यह चुनौती में भागीदार नहीं है। पहला इसलिए कि मैंने चुनौती खुद से पूछी और दूसरी यह कि यह मेरा कोड नहीं है। सभी क्रेडिट स्टीफन पोचमैन के हैं , जिन्होंने रुबिक के क्यूब के अनुकरण के इस भयानक तरीके की खोज की। मैंने केवल चुनौती के संबंध में कुछ गोल्फ और कुछ छोटे बदलाव किए।

def f(a):
 s=t="UF UR UB UL DF DR DB DL FR FL BR BL UFR URB UBL ULF DRF DFL DLB DBR".split()
 for m in a.split():q="FLBR FRBL FDBU FUBD URDL ULDR".split()['UDLRFB'.index(m[0])];n=2+"2'".find(m[-1]);s=[[p,p.translate(str.maketrans(q,q[n:]+q[:n]))][m[0]in p]for p in s]
 return s==t

इसके पीछे का विचार निम्नलिखित है। sके टुकड़े के स्थान का प्रतिनिधित्व करता है UF, URऔर पर इतना। उदाहरण के लिए: s = ['DF', 'BL', ...]इसका मतलब है, कि टुकड़ा UFस्थिति में है DF, टुकड़ा URस्थिति में है BL, ...

एक चाल करते समय एक टुकड़ा की स्थिति कैसे बदल जाती है। यदि आप एक- Uकबूतर करते हैं, -लेयर के सभी स्टिकर (रंग) U, जो सामने वाले चेहरे का सामना करते हैं, तो बाएं चेहरे पर जाएं। बाएं चेहरे के स्टिकर पीछे की ओर बढ़ते हैं, ये दाईं ओर और ये सामने वाले के चेहरे पर होते हैं। द्वारा एन्कोड किया गया FLBR। कुछ उदाहरण: UFचलते हैं UL, UFRआगे बढ़ते हैं , ULFइत्यादि। इसलिए, एक चाल को लागू करना बस इसी परत में टुकड़ों के चेहरे का अनुवाद करना है।