प्रोग्रामर होने के नाते, हमें फ्लेक्स देखना बहुत दिलचस्प नहीं है। आज हम उसे बदल देते हैं! इस चुनौती में आप लेक्स और फ्लेक्स हेक्साफ़्लेक्सागोन करेंगे।

के बारे में

वीडियो परिचय के लिए, फ्लेक्सैगन्स पर विहार वीडियो देखें

एक फ्लेक्सागॉन एक ऐसा आकार है जिसे आप ऊपर और नीचे एक के अलावा अन्य चेहरे प्रकट करने के लिए फ्लेक्स कर सकते हैं; हम एक हेक्साहेक्सफ्लेक्सागान बना रहे हैं, जिसमें 6 चेहरे हैं। नीचे दी गई छवि को देखें कि कागज की एक पट्टी से एक हेक्साहेक्सफ्लेक्सागन को कैसे मोड़ना है।

Aपट्टी के दोनों किनारों को दर्शाता है। दो सफेद त्रिकोण एक साथ सरेस से जोड़ा हुआ है। इस तरह आप इसे फ्लेक्स करेंगे:

नीचे संभावित राज्यों और उनके रिश्तों का एक चित्र है:

रंगीन मंडल पहली छवि से समान संख्या के साथ 6 त्रिकोणों का प्रतिनिधित्व करते हैं। प्रत्येक circes में दो रंग होते हैं- नीचे का सबसे पीछे का चेहरा (आप अपने फ्लेक्सागन को इधर-उधर फ्लिप करने पर क्या देखेंगे) का प्रतिनिधित्व करते हैं, जिसे आपको इस चुनौती पर विचार करने की आवश्यकता नहीं है।

पृष्ठभूमि में स्लेटी वृत्तों का प्रतिनिधित्व करते हैं कि कैसे आप किसी भी राज्य में अपने flexagon फ्लेक्स कर सकते हैं: वहाँ यह फ्लेक्स के लिए 4 विभिन्न तरीके हैं, हम इन फोन Left, Right, Upऔर Down। आप वास्तव में इन दिशाओं में फ्लेक्स नहीं करते हैं, महत्वपूर्ण यह है कि कुछ एक-दूसरे के विपरीत हैं।
यदि आप केंद्र में हैं तो आप उपयोग कर सकते हैं Leftऔर Rightअन्य केंद्रों में जा सकते हैं। आपके द्वारा उपयोग किए जाने वाले केंद्र से बाहर निकलने के लिए Upऔर Down। यदि आप केंद्र में नहीं हैं तो आप उपयोग नहीं कर सकतेLeftया Right।

Left/Down = clockwise
Right/Up  = anti-clockwise

चुनौती

एक फ़ंक्शन या प्रोग्राम बनाएं जो इनपुट के रूप में लेते हैं जो कि 18 मोर्चे के चेहरे और एक फ्लेक्सागॉन के 18 पीछे के चेहरे पर होना चाहिए, बाएं, दाएं, ऊपर और नीचे के फ्लेक्स का एक क्रम है, और फ्लेक्स के बाद 8 दृश्यमान चेहरे लौटाएं।

विस्तृत उदाहरण संगणना:

flex "hexaflexaperplexia" 
     "flexagationdevices" 
     [Right, Right, Left]

Divide a strip of paper into 18 triangles:
1/2\3/1\2/3\1/2\3/1\2/3\1/2\3/1\2/3   Front
4/4\5/5\6/6\4/4\5/5\6/6\4/4\5/5\6/6   Back

Write "hexaflexaperplexia" on the front of the paper strip:
1/2\3/1\2/3\1/2\3/1\2/3\1/2\3/1\2/3

hexaflexaperplexia
123123123123123123
h  a  e  p  p  x     Face 1, Initially the front face
 e  f  x  e  l  i    Face 2, Initially the back face
  x  l  a  r  e  a   Face 3, Initially hidden


Write "flexagationdevices" on the back of the paperstrip:
4/4\5/5\6/6\4/4\5/5\6/6\4/4\5/5\6/6

flexagationdevices
445566445566445566
fl    at    ev       Face 4, up from 3
  ex    io    ic     Face 5, up from 2
    ag    nd    es   Face 6, up from 1


Flex it [Right, Right, Left]
  The initial visible face is 1: "haeppx"
  flexing Right ..
  The current visible face is 2: "efxeli"
  flexing Right ..
  The current visible face is 3: "xlarea"
  flexing Left ..
  The current visible face is 2: "efxeli"
  flexed [Right, Right, Left]!

outputting "efxeli"

उदाहरण कार्यान्वयन: http://jdoodle.com/a/18A

इनपुट और अपेक्षित आउटपुट:

> hexaflexaperplexia flexagationdevices RRL
= efxeli

> loremipsumdolorsit hexaflexamexicania RUU
= riuort

> abcdefghijklmnopqr stuvwxyz1234567890 UL
= I can't flex that way :(

> abcdefghijklmnopqr stuvwxyz1234567890 RRRRLLUDDUUUULDD
= uv1278

नियम

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

— BlackCap
स्रोत

हास्केल (लैंबडॉट), 270 234 बाइट्स

(!)=((map(snd<$>).groupBy((.fst).(==).fst).sortOn fst).).zip.cycle
o n(a,b)|n>1||b<1=(mod(a+[-1,1,0,0]!!n)3,mod(b+[0,0,-1,1]!!n)3)
(x&y)d|(g,h)<-foldl(flip(.))id(o<$>d)(0,0)=([0,1,2]!x++[3,3,4,4,5,5]!y)!!([0,5,1,1,4,2,2,3,0]!!(3*g+h))

उपयोग:

> (&) "hexaflexaperplexia" "flexagationdevices" [1,3]
"exioic"

[0,1,2,3] = [बाएं, दाएं, ऊपर, नीचे]

बहुत सारे बाइट्स के लिए @ डैमियन को धन्यवाद!

— BlackCap
स्रोत

किस काम का |b/=0=[]!!1? आप कुछ बाइट्स को पॉइंटफ्री स्टाइल में कुछ फ़ंक्शन्स को लिखकर बचा सकते हैं: \(a,_)(b,_)->a==b-> (.fst).(==).fst,(!)=(q.).zip.cycle

— डेमियन

@Damien |b/=0=[]!!1सिर्फ एक अपवाद फेंकता है अगर आप एक असंभव फ्लेक्स करने की कोशिश करते हैं

— BlackCap

ठीक है, आप इसे सरल बना सकते हैं इसके साथ ही o n(a,b)|n>1||b<1=(z$a+[-1,1,0,0]!!n,z$b+[0,0,-1,1]!!n)गैर-थकाऊ पैटर्न अपवाद भी होगा