33

एक चींटी एक वायरफ्रेम क्यूब के किनारों (चेहरे नहीं) के साथ चलती है। प्रत्येक शीर्ष पर उसका सामना एक कांटे से होता है, जहां से दो नए किनारों की शाखा निकलती है। चींटी चुनती है कि किस रास्ते को मोड़ना है - leftया right। ये दिशा चींटी के सापेक्ष होती है, जो कशेरुक का सामना कर रही है और घन के बाहर है। आपका लक्ष्य यह निर्धारित करना है कि चींटी ने जो विकल्प left/ rightविकल्प चुने हैं, क्या वह उसी स्थिति में समाप्त होता है, जिस दिन वह शुरू हुआ था।

उदाहरण के लिए, यदि चींटी चार बार बाईं ओर मुड़ती है ( left left left left), तो यह एक वर्गाकार वामावर्त का पता लगा लेती है और उसी स्थान पर समाप्त हो जाती है, जहां से उसने शुरुआत की थी। लेकिन, अगर यह चला जाता है, तो यह left left left left rightघन पर एक अलग स्थान पर समाप्त हो जाएगा। इसके अलावा, अगर यह चला जाता है, तो यह left right right right leftअपने शुरुआती छोर पर समाप्त होता है लेकिन विपरीत शीर्ष का सामना करना पड़ता है, जो एक ही स्थिति के रूप में नहीं गिनता है।

चींटी का रास्ता किनारों को दोहरा सकता है, जिसमें यह शुरू हुआ किनारा भी शामिल है, लेकिन पूरे अनुक्रम के बाद यह क्या मायने रखता है।

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

(संपादित करें: यदि आपकी भाषा एक नामित कार्य नहीं कर सकती है, तो यह STDIN / या स्टैक के माध्यम से इनपुट और आउटपुट के साथ फ़ंक्शन को लागू कर सकती है। यदि यह संभव नहीं है, तो इसे एक स्निपेट बनाएं जिसमें इनपुट और आउटपुट सहेजे जाते हैं। चर।)

इनपुट

का एक अनुक्रम left/ rightलंबाई के निर्णय 0करने के लिए 31अपनी पसंद का एक स्वरूप में प्रस्तुत किया समावेशी,। यह अक्षरों की एक स्ट्रिंग R/ L, संख्याओं की सूची 1/ -1या बूलियंस की एक सरणी हो सकती है। उन्हें कोड नाम या तार आपके कोड के लिए उपयोगी होने की तरह कुछ भी नहीं है।

कृपया नीचे दिए गए परीक्षण मामलों से भिन्न होने पर परीक्षण मामलों को अपने प्रारूप में पोस्ट करें।

उत्पादन

True/ False, 0/ 1, या आपकी भाषा में एनालॉग्स।

मानदंड जीतना

सबसे कम बाइट्स जीतता है। याद रखें, आपको एक नामित फ़ंक्शन देने की आवश्यकता है। आपके पास फ़ंक्शन के बाहर कोड हो सकता है, लेकिन वे बाइट्स भी गिनते हैं। यदि कई बार कॉल किया जाता है तो आपके फ़ंक्शन को सही ढंग से व्यवहार करना चाहिए।

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

True मामले (एक प्रति पंक्ति, दूसरा एक खाली सूची है):

1 1 1 1

-1 -1 -1 -1
1 -1 1 -1 1 -1
1 1 -1 -1 1 1 -1 -1
-1 1 1 -1 -1 1 1 -1
1 1 1 -1 -1 -1 -1 1
1 -1 -1 1 -1 -1
1 1 1 1 -1 -1 -1 -1 1 -1 -1 1 -1 -1
-1 -1 -1 1 -1 -1 1 1 -1 1 -1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1

False मामले (प्रति पंक्ति एक):

1
1 1
1 1 1
-1 1
1 -1 -1 -1 1
1 -1 -1 1 1
-1 1 -1 1
1 1 1 1 -1
-1 -1 1 -1 1 -1 -1 1
1 -1 1 1 1 1 -1 -1 -1 1 1 -1 -1 -1

यहाँ L's और R' s के साथ एक ही परीक्षण के मामले हैं ।

True मामलों:

RRRR

LLLL
RLRLRL
RRLLRRLL
LRRLLRRL
RRRLLLLR
RLLRLL
RRRRLLLLRLLRLL
LLLRLLRRLRLRRRRRRRRRRRRRRRRR

False मामलों:

R
RR
RRR
LR
RLLLR
RLLRR
LRLR
RRRRL
LLRLRLLR
RLRRRRLLLRRLLL

अतिरिक्त ऋण चुनौती

एक ही बात है, लेकिन एक घन के बजाय एक dodecahedron के साथ । विचारों के लिए हंट द वम्पस देखें ।

code-golf

— XNOR
स्रोत

क्या यह नामित कार्यों के बिना भाषाओं के उपयोग को रोकता है?

— माइक प्रेप

@MikePrecup क्या आप मुझे ऐसी भाषाओं के कुछ उदाहरण दे सकते हैं? मैं विकल्पों पर गौर करूंगा।

— xnor

मैं अपने सभी कोड गोल्फ सबमिशन > <> में करता हूं, यही कारण है कि मैं पूछता हूं। इसमें एक स्टैक है जिसे आप शीर्ष पर आर्ग को लोड कर सकते हैं, और फिर परिणाम को स्टैक पर छोड़ सकते हैं, लेकिन यह वास्तव में एक नामित फ़ंक्शन नहीं है।

— माइक प्रीची

@MikePrecup ठीक है, मैंने उसके लिए एक भत्ता रखा। यदि अभी भी कुछ भाषा के लिए कोई समस्या है, तो कृपया मुझे बताएं, मैं किसी भी भाषा को बाहर नहीं करना चाहता।

— xnor

मैं इस तरह की भाषाओं के बारे में सोच सकता हूं

— गर्व haskeller

21

GolfScript, 24 वर्ण (केवल फ़ंक्शन बॉडी के लिए 19)

गणित FTW!

{3,.@{[+~@\{@}*~]}/=}:f;

इस समाधान का परीक्षण ऑनलाइन करें।

यह फ़ंक्शन इनपुट को एक बाइनरी एरे के रूप में लेता है (बाएं के लिए 0, दाएं के लिए 1) और सच के लिए 1 और झूठ के लिए 0 देता है।

वैचारिक रूप से, यह क्यूब को घुमाकर काम करता है ताकि चींटी हमेशा एक ही स्थिति और अभिविन्यास बनाए रखे, और यह जाँच ले कि क्यूब अंत में उसी ओरिएंटेशन में समाप्त होता है जैसे कि यह शुरू हुआ था।

विशेष रूप से, हम तीन आयामों में दो रेखीय नक्शे के रूप में बाएँ और दाएँ मुड़ते हैं, जहाँ बाएँ मोड़ x अक्ष के चारों ओर 90 ° घूमने से मेल खाता है , अर्थात मानचित्र ( x , y , z ) → ( x , z ,) - y ), और दायां मोड़ y अक्ष के चारों ओर 90 ° घूमने से मेल खाता है , अर्थात मानचित्र ( x , y , z) ) → ( z , y , - x )।

फ़ंक्शन की शुरुआत में, हम बस एक तीन-तत्व वेक्टर सेट करते हैं जिसमें अलग-अलग सकारात्मक मान (1, 2, 3) होते हैं, इसके लिए रोटेशन मैप्स के अनुक्रम को लागू करते हैं, और जांचें कि क्या परिणामस्वरूप वेक्टर प्रारंभिक एक के बराबर है।

(वास्तव में, कुछ वर्णों को बचाने के लिए, मैं वास्तव में निर्देशांक को रूपांतरित करता हूं ताकि प्रारंभिक वेक्टर (0, 1, 2) हो और नक्शे ( x , y , z ) → ( x , z , −1− y ) हों और ( x , y , z ) → ( z , y , −1 ) x ), लेकिन अंतिम परिणाम समान है।)

Ps। इस समाधान के मूल संस्करण में बग को स्पॉट करने के लिए गर्व हैस्केलर के लिए धन्यवाद ।

पर्ल, 58 वर्ण

टिप्पणियों में अनुरोध के अनुसार, यहां एक ही समाधान पर्ल के लिए रखा गया है। (यह संस्करण वास्तव में अनियंत्रित निर्देशांक का उपयोग करता है, क्योंकि परिवर्तन पर्ल में कोई वर्ण नहीं बचाता है।)

sub f{@a=@b=1..3;@a[$_,2]=($a[2],-$a[$_])for@_;"@a"eq"@b"}

इस समाधान का परीक्षण ऑनलाइन करें।

बोनस: चींटी ऑन ए डोडेकेहेड्रॉन (गोल्फस्क्रिप्ट, 26 वर्ण)

{5,.@{{2*2%[~\]}*(+}/=}:f;

इस समाधान का परीक्षण ऑनलाइन करें।

ऊपर दिए गए एंटी-ऑन-ए-क्यूब फ़ंक्शन की तरह, यह फ़ंक्शन एक बाइनरी एरे के रूप में लेता है (बाएं के लिए 0, दाएं के लिए 1) और रिटर्न 1 होता है यदि चींटी उसी स्थिति और ओरिएंटेशन पर समाप्त होती है जैसा कि इसमें शुरू हुआ, या 0। अन्यथा।

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

इस प्रकार, हम सभी को करने की जरूरत है दो क्रमपरिवर्तन एल और आर पाएं जो बाएं और दाएं घुमाव का प्रतिनिधित्व कर सकते हैं। विशेष रूप से, इन क्रमपरिवर्तन 5-चक्र होने की जरूरत है (ताकि उन्हें मूल अवस्था में पांच बार रिटर्न लागू करने), वे एक दूसरे (यानी की शक्तियों नहीं होना चाहिए आर ≠ एल ^एन किसी के लिए n ), और वे संबंध को संतुष्ट करने की जरूरत है ( एलआर ) ⁵ = (1), जहां (1) पहचान क्रमोन्नति को दर्शाता है। (वास्तव में, यह मानदंड बताता है कि पथLRLRLRLRLR को मूल स्थिति पर लौटना होगा।)

फिक्सिंग एल क्रमचय बाईं, यानी मानचित्रण (के लिए एक सरल बैरल पारी होने के लिए एक , ख , ग , घ , ङ ) → ( ख , ग , घ , ई , एक ,) के बाद से यह सिर्फ दो में GolfScript में लागू किया जा सकता chars ( (+), हम पाते हैं कि आर क्रमपरिवर्तन के लिए पाँच संभावित विकल्प हैं। उनमें से, मैंने मैपिंग को चुना ( ए , बी , सी , डी , ई ) → ( सी , ई , डी ,)बी , अंत करने के लिए।)क ), चूंकि इसमें अपेक्षाकृत कॉम्पैक्ट गोल्फस्क्रिप्ट कार्यान्वयन भी है। (वास्तव में, मैं यह पहली बार साथ तत्वों interleaving द्वारा लागू 2*2%प्राप्त करने के लिए ( एक , ग , ई , बी , डी ), तो पिछले दो तत्वों की अदला-बदली [~\], और अंत में लागू करने के एल क्रमचय बिना शर्त स्थानांतरित करने के लिए एक

ऊपर दिए गए ऑनलाइन डेमो लिंक में डोडेकाहेड्रोन पर वैध रास्तों के कुछ परीक्षण मामले शामिल हैं जो मूल में वापस आते हैं, जैसे:

           # empty path
1 1 1 1 1  # clockwise loop
0 0 0 0 0  # counterclockwise loop
1 0 0 0 0 1 1 0 0 0 0 1  # figure of 8
1 0 1 0 1 0 1 0 1 0      # grand circle
1 0 0 0 1 0 0 0          # loop around two faces 
1 0 0 0 1 1 1 0 1 0 1 0 0 0 1 1 1 0 1 0  # Hamilton cycle

— इल्मरी करोनें
स्रोत

अच्छा समाधान! क्या यह मामले को बाहर करता है हालांकि चींटी एक ही दिशा से एक ही शीर्ष पर वापस आती है?

— xnor

मुझे समझ में नहीं आ रहा है - मूल रूप से आप यहाँ क्या कर रहे हैं 3 बिट्स का उपयोग करके चींटी की स्थिति का प्रतिनिधित्व कर रहे हैं, लेकिन 24 संभावित स्थान हैं। कैसे?

— गर्वित हैकेलर

1

@proudhaskeller: बग को स्पॉट करने के लिए धन्यवाद। मैंने इसे ठीक कर लिया है, और अपने प्रतिरूप को मेरे परीक्षण सूट में जोड़ दिया है।

— इल्मरी करोनें

1

@ xnor: डोडेकाहेड्रोन के लिए एक समाधान भी जोड़ा गया।

— इल्मरी करोनें

1

डोडेकाहेड्रोन के लिए क्रमपरिवर्तन की अच्छी जोड़ी। हंट द वम्पस के लिए मैं जिन लोगों का इस्तेमाल करता था, वे लंबे समय तक एक हो सकते हैं: {[~@]-1%}*[~@]या ){[~@]-1%}*-1%आपकी जगह{2*2%[~\]}*(+

— पीटर टेलर

7

अजगर, ६th

1 और -1 की सूची लेता है। 3 डी घुमावों के आधार पर: यह जांच करता है कि बिंदु (3,2,1) घुमावों की श्रृंखला को लागू करने के बाद उसी स्थिति में समाप्त हो जाता है या नहीं। 1 और -1 के संगत दो संभावित घुमाव हैं। प्रत्येक को दो निर्देशांक की अनुमति देकर और उनमें से एक के संकेत को बदलकर किया जाता है। बदलने के लिए सटीक निर्देशांक और कौन सा संकेत परमिट के लिए महत्वपूर्ण नहीं है।

def f(l):
 p=[3,2,1]
 for d in l:p[d],p[0]=-p[0],p[d]
 return[3,2]<p

संपादित करें: यह वास्तव में "पर्ल, 58" के समान समाधान है।

— आर्मिन रिगो
स्रोत

आप सही कह रहे हैं, यह वास्तव में है।

— गौरवशाली हैकेलर

+1, यह अभी भी पायथन समाधान में मेरे प्रयास से कम है। मेरे पास जो है, उसे देखते हुए, मुझे लगता है कि आप इनपुट को 0s और 1s के रूप में ले कर कुछ और चार्ट को बचा सकते हैं और pएक अलग चर में अंतिम तत्व को विभाजित कर सकते हैं।

— इल्मरी करोनें

3

वाह, मैंने चर नामों को छोड़कर चरित्र के लिए सटीक एक ही समाधान , चरित्र लिखा , जब इस समस्या का परीक्षण-हल!

— xnor

5

मेथेमेटिका

इल्मरी करोनन के समाधान से प्रेरित। क्यूब का घूर्णी समरूपता समूह एस _{4 के} लिए आइसोमॉर्फिक है ।

क्यूब, 51 बाइट्स

Fold[Part,r=Range@4,{{2,3,4,1},{3,4,2,1}}[[#]]]==r&

इनपुट के रूप में 1s और -1s की सूची लेता है ।

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

डोडेकेहेड्रोन, 55 बाइट्स

Fold[Part,r=Range@5,{{2,3,4,5,1},{3,5,4,2,1}}[[#]]]==r&

इनपुट के रूप में 1s और -1s की सूची लेता है ।

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

— alephalpha
स्रोत

मैं खोज रहा था कि यह कैसे पाया जा सकता है कि यह S3 के लिए आइसोमोर्फिक है?

— गौरवशाली हैकेलर

उफ़ का मतलब था "यह कैसे पाया / सिद्ध किया जा सकता है कि यह एस 4 के लिए समरूप है?

— गर्व हैस्केलर

@proudhaskeller आप इसे यहां देख सकते हैं: en.wikipedia.org/wiki/Octahedral_symmetry

— alephalpha

5

C (gcc) , 118 116 107 105 बाइट्स

सीट्स के लिए -2 बाइट्स धन्यवाद

f(char*s){char*p,n[]="@ABCDEFG",y;for(;*s;s++)for(p=n;*p;*p++^=*s^82?y%2+1:4-(y&2))y=*p/2^*p;y=n[2]==66;}

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

मान लीजिए कि हमने घन को निम्नलिखित निर्देश दिए हैं:

            (1,1,1)       (1,1,0)
          G +--------------+ C
           /|             /|
          / |            / |
         /  |    (0,1,0)/  |
(0,1,1) +--------------+ D |
      H |   |          |   |
        |   |          |   |
        | F +----------|---+ (1,0,0)
        |  /(1,0,1)    |  / B           x
        | /            | /           y / 
        |/             |/            |/  
      E +--------------+ A      z ---*   
        (0,0,1)       (0,0,0)

यदि हम कोने डी पर शुरू करते हैं, तो सी या एच में जाने के बजाय हमारे चारों ओर घन को घुमाने के बारे में सोचा जा सकता है। दाएं घूमने का मतलब Z अक्ष के चारों ओर काउंटर-क्लॉकवाइज घूमना होगा, और बाईं ओर घूमने का मतलब एक्स अक्ष के चारों ओर दक्षिणावर्त घूमना होगा। ये केवल दो घुमाव हैं जिनकी हमें देखभाल करने की आवश्यकता है। चूंकि प्रत्येक घुमाव बिल्कुल 90 डिग्री है, हम किनारों के साथ "स्लाइडिंग" की कल्पना कर सकते हैं। दाएं चलने के लिए, इसका मतलब ए -> बी, बी -> सी, सी -> डी, डी -> ए है, जबकि दूसरी तरफ ई -> एफ आदि के साथ बाएं घूमने के लिए, हमें इसके बजाय ए -> ई, ई - मिलता है। > एच आदि।

चूंकि प्रत्येक कोने केवल एक किनारे के साथ स्लाइड करते हैं, इसका मतलब है कि प्रत्येक घुमाव के लिए प्रत्येक बिंदु के आयाम में से केवल एक ही बदलता है। जब B, C पर जाता है, केवल उसका y घटक बदलता है, और जब H, D से चलता है, तो केवल उसका Z घटक बदलता है, और इसी तरह। इसके अलावा, चूंकि निर्देशांक 0 और 1 तक सीमित हैं, इसलिए हम प्रत्येक बिंदु को एक द्विआधारी संख्या के रूप में सोच सकते हैं, जिसके साथ आंदोलन पर उपयुक्त बिट फ़्लिप किया जा सकता है।

हम देख सकते हैं कि दाईं ओर एक आंदोलन के लिए, ए और सी अपने एक्स को फ्लिप करते हैं, जबकि डी और बी अपने वाई को फ्लिप करते हैं। यदि हम क्यूब हेड के उस तरफ देखने के लिए परिप्रेक्ष्य बदलते हैं, और जेड घटक (जो इस रोटेशन के लिए वैसे भी नहीं बदलता है) को अनदेखा करते हैं:

D (0,1)         C (1,1)
 +-------------+
 |             |
 |             |
 |             |
 |             |
 |             |
 |             |
 +-------------+
A (0,0)         B (1,0)

एक पैटर्न उभरता है: उन बिंदुओं के लिए जो अपने x, x == y को फ्लिप करते हैं, जबकि उनके y के फ़्लिपिंग बिंदुओं के लिए विपरीत सच है। यह दूसरे प्रकार के रोटेशन के लिए है, लेकिन x के बजाय z के साथ है।

दूसरे शब्दों में:

Right
    if (x == y) x = !x
    if (x != y) y = !y

Left
    if (z == y) z = !z
    if (z != y) y = !y

अब हम आसानी से सभी घुमावों से गुजर सकते हैं, और अंत में देखते हैं कि क्या अंतिम डी हमारे प्रारंभिक डी से मेल खाता है।

एक अंक के रूप में प्रत्येक बिंदु को संग्रहीत करना एक दिया गया है, लेकिन सी में, एक चार सरणी असाइन करना एक अंतर सरणी की तुलना में बहुत अधिक कॉम्पैक्ट है। हम उन पात्रों को चुनने का ध्यान रखते हैं जिनके निचले तीन बिट्स 000..111 से मेल खाते हैं, जिससे बाकी के बिट्स को अनदेखा करना संभव हो जाता है। निर्देशांक को फ़्लिप करना बस उपयुक्त बिटकॉइन के साथ XOR'ing का मामला है।

— gastropner
स्रोत

1

लंबे स्पष्टीकरण के लिए बहुत बहुत धन्यवाद, अन्य उत्तर मेरे सिर में काफी क्लिक नहीं करते थे, लेकिन यह तुरंत समझ में आया।

— नित

4

अजगर - 110, 150

पूर्णांक के साथ पूर्णांक के -1लिए सूची में ले जाता है , 1दाएं मुड़ने के लिए।

घन, 110:

def f(l):
    c,p='07'
    for d in l:a="100134462634671073525275"[int(c)::8];c,p=a[(a.index(p)+d)%3],c
    return'1'>c

परीक्षा:

l=map(int,'1 1 1 1'.split())
print f(l)

डोडेकाहेड्रोन, 150:

def f(l):
    c,p='0J'
    for d in l:a="I5H76E8BBA8F76543100JI0J21D3A5C7E9CJI2132H4GF94C6D98AHGBEDGF"[int(c,36)::20];c,p=a[(a.index(p)+d)%3],c
    return'1'>c

— vectorized
स्रोत

1

यह प्रभावशाली है कि आपने इसे तीन मिनट में कैसे लिखा है :-P

— xnor

6

बहुत समय से इस बॉस के सवाल का इंतजार किया जा रहा है। ;-)

— वेक्टर

जब मैं Python 3.2 में इसे चलाता हूं तो मुझे "TypeError: बफर इंटरफेस के साथ एक ऑब्जेक्ट की उम्मीद है" मिल रहा है।

— xnor

@xnor संपादित, अब अजगर 2 में। आशा है कि यह काम करता है।

— १०:१६

4

मारबेलस 188

नई भाषा दिखाने के उद्देश्य से इल्मरी करोनन के एल्गोरिथ्म की बेशर्म चोरी ।

इस लिपि में स्टैक पर दाईं ओर के लिए 0x00 की एक स्ट्रिंग और 0x0A (न्यूलाइन) के बाद 0x01 की स्ट्रिंग की अपेक्षा है। यह एक असफल मामले के लिए "0" और एक सफलता के लिए "1" आउटपुट करता है।

......@5@3FF
@0@1@2\\]]@5
010203@4=A@4
&0&0&0&0/\
MVMVMVMV..
@0@1@2@3..!!
:MV
}2}2}1}0}1}0}3
&0&1&0&1~~~~<A@P
{0{1{1{0&1&0=0&1
}0}1}2@P{2{2&030
=1=2=3&2FF}3..//
&2&2&231&2{3
\/\/\/&2!!..//

उदाहरण रन:

# echo -e "\x0\x0\x0\x1\x0\x0\x1\x1\x0\x1\x0\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1\x1" | marbelous.py ant-on-a-cube.mbl
1

— Sparr
स्रोत

1

मुझे इस बात का अहसास नहीं था कि जब तक मैं भाषा का विवरण नहीं पढ़ता, तब तक यह उत्तर कितना पागल होगा। यह एक गोल्फ भाषा के लिए एक बहुत अच्छी अवधारणा है!

— xnor

@xnor यह गोल्फ के क्षेत्र में कभी भी एक गंभीर प्रतियोगी होने की संभावना नहीं है, लेकिन यह अभी भी कुछ हद तक मज़ेदार है :)

— 16

4

पायथन 2 , 57 बाइट्स

f=lambda l:reduce(lambda n,x:n%4*64+n/4*16**x%63,l,27)<28

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

यह क्रमचय प्रतिनिधित्व का उपयोग करता है

0: abcd -> dabc
1: abcd -> dcab

जहाँ बाएँ और दाएँ (0 और 1) 4 तत्वों पर लंबाई -4 चक्र के अनुरूप हैं। हम संकेत किए गए क्रमपरिवर्तन को लागू करने वाले इनपुट पर पुनरावृत्ति करते हैं, और जांचते हैं कि परिणाम प्रारंभिक मूल्य के बराबर है या नहीं।

हम a,b,c,dचार-तत्व सूची के रूप में शुरू करते हैं 0,1,2,3। हम एक एकल आधार -4 संख्या में उन्हें संकुचित n=abcd, प्रारंभिक मूल्य के साथ n=27करने के लिए इसी 0123आधार 4 में हम एक दृष्टांत क्रमचय हिसाब से परn ।

चूंकि दोनों परिणाम शुरू होते हैं d, हम n%4निकालने के लिए कर सकते हैं d, फिर n%4*64इसे सही स्थिति में ले जाने के लिए d___। अन्य अंक के abcरूप में निकाले जाते हैंn/4 । हमें उन्हें निचले तीन स्थान मूल्यों में सम्मिलित करने की आवश्यकता है।

दिशा के लिए x=0, हम abcजैसा है, और के लिए x=1, हम उन्हें घुमाएँ cab। रोटेशन के रूप में प्राप्त किया जा सकता है *16%63, जो abcकरने के abc00लिए लेता है cab। ( %63पर गलत हो जाएगा a==b==c==3, लेकिन ये मूल्य संभव नहीं हैं।) चूंकि सिर्फ करना %63एक नो-ऑप है, दिशा-निर्भर अभिव्यक्ति *16**x%63देता है abcया cabआवश्यकतानुसार।

पायथन 2 , 55 बाइट्स

f=lambda l:reduce(lambda n,x:n^(n*8%63|7*8**x),l,10)<11

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

— XNOR
स्रोत

3

हास्केल, 104 103 99 97 96/ 67 64 वर्ण

~~मुझे लगता है कि दाएं / बाएं का समतुल्य एक डायटाइप की दिशा होगी जैसे:~~

~~Direction = R | L~~

~~इसलिए मैंने अपने उत्तर में मान लिया कि वे उपलब्ध थे।~~
संपादित करें: वास्तव में एहसास हुआ कि बुलियन छोटे कोड की ओर ले जाएंगे। ट्रू एक लेफ्ट टर्न का प्रतिनिधित्व करता है, और फाल्स एक राइट टर्न का प्रतिनिधित्व करता है (हालाँकि, तकनीकी रूप से, कोड उसी तरह काम करेगा यदि इसे फ़्लिप किया गया था; यह सममित है)

96 वर्ण:

m[p,l,r]b|b=[p%l,7-r-l,r]|0<1=[p%r,l,7-r-l]
p%x|odd$div p x=p-x|0<1=p+x
g l=foldl m[0..2]l<[0,2]

g एक ऐसा फंक्शन है जिसे दिशा की एक सूची दी गई है, चींटी का मौसम वापस नहीं आएगा क्योंकि चींटी अपनी जगह पर वापस आ गई।

स्थिति के प्रतिनिधित्व की व्याख्या: चींटी की स्थिति को पूर्णांक के तीन टपल के रूप में कोडित किया जाता है। पहला पूर्णांक उस शीर्ष का प्रतिनिधित्व करता है जो चींटी की ओर जा रहा है। पहले बिट का प्रतिनिधित्व करता है यदि शीर्ष ऊपर / नीचे आधे पर है, दूसरा बाएं / दाएं आधा है, और तीसरा पीछे / सामने आधा है। ऐसा इसलिए किया जाता है ताकि एक शिखर से पड़ोसी की चोटी पर जाने से एक बिट को फ़्लिप करके किया जा सके।

दूसरा पूर्णांक वह राशि है जो चींटी के शीर्ष में बदल जाती है यदि वह बाईं ओर जाएगी। उदाहरण के लिए, यदि चींटी शीर्ष 3 पर थी, और दूसरा पूर्णांक 4 था, तो बाईं ओर मुड़ने के बाद शीर्ष 7 होगा। ध्यान दें कि यह हमेशा 2 की शक्ति होगी, क्योंकि वास्तव में एक बिट को एक शीर्ष स्थानांतरित करके फ़्लिप किया जाता है।

तीसरा पूर्णांक वही है, लेकिन सही जाने के लिए; मुझे पता है कि यह पहले दो द्वारा गणना की जा सकती है, लेकिन मुझे नहीं पता कि कैसे। यदि आपको कोई विचार आया हो, तो कृपया मुझे बताएं।

ध्यान देने वाली बात यह है कि बाएं मुड़ने पर, तीसरा पूर्णांक एक ही रहेगा, और दूसरा 1 2 और 4 के बीच होगा, जो या तो दूसरा पूर्णांक या तीसरा नहीं था, जो कि 7 के समान होता है - दूसरा पूर्णांक - तीसरा पूर्णांक।

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

कार्यों की व्याख्या:

(%) फ़ंक्शन वह फ़ंक्शन है जो वर्तमान वर्टेक्स और इसे बदलने के लिए राशि लेता है, और इसे बदलता है। यह उस बिट को जाता है जो बदलने वाला है और इसे (बहुत ही संख्यात्मक तरीके से) फ़्लिप करता है।

m फंक्शन एक ऐसा फंक्शन है जो चींटी, और दिशा की स्थिति लेता है, और हमने पहले बताए गए नोट का उपयोग करके नई स्थिति लौटाता है।

तब m फंक्शन जोड़ का उपयोग करके जोड़ दिया जाता है (जो कि reduceजावास्क्रिप्ट की तरह है, लेकिन फ़ंक्शन g बनाने के लिए थोड़ा और अधिक अभिव्यंजक है), इस प्रश्न का उत्तर।

हास्केल, 64 वर्ण

@ अल्फाल्फा के उत्तर से प्रेरित होकर, यह हैशेल में चित्रित किया गया संस्करण है:

m[a,b,c,d]p|p=[b,c,d,a]|0<1=[b,d,a,c]
g l=foldl m[0..3]l<[0,1,3]

संपादित करें: अब मैं लामरी करोनन के जवाब के कारण अविश्वसनीय रूप से बेवकूफ महसूस कर रहा हूं। शायद मैं haskell करने के लिए अपने जवाब बंदरगाह हूँ। एक और संपादित करें: बेवकूफ के रूप में महसूस नहीं कर उसके जवाब के रूप में ~~किया जाता है~~ गलत था
संपादित करें: वास्तव में tuples का उपयोग करने से उनके रूप में सूची का उपयोग करने के लिए बंद कर Ordउदाहरण और [ ... ]वाक्यात्मक चीनी इसे छोटा बनाता है

— गर्वित हेकलर
स्रोत

1

यह बहुत सुंदर लग रहा है, विशेष रूप से गुना। हो सकता है कि यह [0,1,2,3]एक चर को असाइन करने के लिए अभी तक अधिक वर्णों को बचाए और इसे अभिव्यक्ति और इनपुट के लिए इनपुट के रूप में उपयोग करें?

— xnor

@xnor क्योंकि आपकी टिप्पणी मेरे मन ने इसे गोल्फ के साथ आने का फैसला किया [0..3]... मुझे नहीं पता कि मैंने पहले क्यों नहीं देखा। धन्यवाद। लेकिन अब आपकी चाल काम नहीं करती है। ओह अच्छा।

— गर्वित हैकेलर

3

हास्केल , 53 बाइट्स

f=(<28).foldl(\n x->mod n 4*64+mod(div n 4*16^x)63)27

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

मेरे पाइथन के जवाब के समान तर्क , यहां तक कि सोचा modऔर divलिखने के लिए लंबा है।

हास्केल , 58 बाइट्स

r=[1..3]
f=(==r).foldl(\[x,y,z]->(!!)[[x,-z,y],[-z,y,x]])r

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

— XNOR
स्रोत

3

APL (Dyalog Unicode) , 22 बाइट्स ( Adám's SBCS )

f←{x∊(-@3∘⌽⌽)/⍵,x←⊂⍳3}

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

H.PWiz ने सुझाव दिया कि चरणों को उलटने से कोई फर्क नहीं पड़ता है, और इसके परिणामस्वरूप -2 बाइट्स होते हैं।

खैर, यह शर्मनाक है, क्योंकि यह गोल्फस्क्रिप्ट की तुलना में छोटा होने का इरादा था। कम से कम मैंने कोशिश तो की।

फ़ंक्शन का नाम है f, और, परीक्षण मामलों में, 1एक बाएं मोड़ (बूलीयन ट्रू) का 0प्रतिनिधित्व करता है और एक सही मोड़ (बूलियन झूठी) का प्रतिनिधित्व करता है। ⍬खाली सूची का प्रतिनिधित्व करता है।

— आउटगोल्फर को एरिक करें
स्रोत

3

एपीएल (डायलॉग) , 21 बाइट्स

f←{x≡(↓∪⊢∘⌽)/⍵,x←⊂⍳4}

इसे ऑनलाइन आज़माएं! (एरिक आउटग्लोफर के उत्तर से परीक्षण वातावरण का उपयोग करते हुए )

मैं चला लेते हैं और के रूप में सही 1और 2। यह निम्नलिखित क्रमपरिवर्तन का उपयोग करता है abcd:

1 : bcda
2 : cdba

मैं लागू करने के लिए इसी क्रम-परिवर्तन 1और 2करने के लिए ⍳4 : 1 2 3 4, और देखें कि क्या यह अपरिवर्तित है

— H.PWiz
स्रोत

20 के लिए सच में फंक्शन नाम दिया गया है

— Adám

3

बैश , 71 65 बाइट्स

f()(a=1234;for i;{ a=`tr 1-4 4$[$i?123:312]<<<$a`;};((a==1234));)

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

पिछले कई उत्तरों की तरह, 1234-> 4123 और 1234- 4312 द्वारा उत्पन्न क्यूब के घूर्णन के समूह का प्रतिनिधित्व करता है। अक्षरों के बजाय संख्याओं का उपयोग करता है ताकि मैं एक अंकगणितीय ऑपरेटर का उपयोग अंकगणितीय विस्तार के साथ कर सकूं। अपने इनपुट को 0 के रूप में और 1 को रिक्त स्थान द्वारा अलग करने की अपेक्षा करता है, और बाहर निकलने के कोड के माध्यम से आउटपुट करता है।

6 बाइट्स ने @ manatwork की टिप्पणी के लिए धन्यवाद बचाया!

— सोफिया लेचनर
स्रोत

1

देखें डेनिस के बैश टिप पैरामीटर सूची पर पाशन के बारे में।

— मैनेटवर्क

3

brainfuck , 119 बाइट्स, 137 बाइट्स

इस तथ्य का उपयोग करता है कि क्यूब का रोटेशन समूह आइसोमॉर्फिक है $S_4$ । Brainfuck का कोई कार्य नहीं है, नाम या अन्यथा, इसलिए यह एक पूर्ण कार्यक्रम है जो STDIN के माध्यम से इनपुट लेता है और STDOUT को आउटपुट देता है। (यदि आप एक चर पर जोर देते हैं, तो उस प्रोग्राम के समाप्त होने का मान दिखाते हैं जिस पर चर समाप्त होता है।)

घन, 119 बाइट्स

++++>+++>++>+>,[+++[->+++<]<<<<[->>>>+<<<<]>[>]<+[[-]<[->+<]<<<[->>>+<<<]>[>]],]<[[<]>[->]<[>>]<]<[>>-<]-[----->+<]>--.

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

++++>+++>++>+    Initialize tape as 4 3 2 1

>,[              For each input byte:

  +++[->+++<]       Add 3 and multiply by 3; if input is R, this will be 255

  <<<<[->>>>+<<<<]  Move first number to end (BCDA)

  >[>]<+[           If input wasn't R:

    [-]                Zero input cell (which is now negative 18)

    <[->+<]            Move previously moved number one slot further (BCD_A)

    <<<[->>>+<<<]      Move first number into vacated slot (CDBA)

  >[>]]

,]

<[[<]>[->]<[>>]<]     Determine whether tape is still 4 3 2 1

<[>>-<]               If not: subtract 1 from output cell

-[----->+<]>--.       Create "1" in output cell and output

डोडेकाहेड्रोन, 137 बाइट्स

+++++>++++>+++>++>+>,[+++[->+++<]<<<<<[>>>>>+[<]>-]>[>]<+[[-]<<[[->>+<<]<<]>[>>>>>>+[<]<-]>>[>]],]<[[<]>[->]<[>>]<]<[>>-<]-[----->+<]>--.

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

दो कार्यक्रमों के बीच अंतर केवल सेटअप और क्रमपरिवर्तन हैं। यहां इस्तेमाल किया गया बाईं क्रमपरिवर्तन है DCAEB, जो लगता है कि गोल्फ का सबसे अच्छा संयोजन उपलब्ध था।

— Nitrodon
स्रोत

1

जेली , 14 बाइट्स

3RðW;ṙN1¦ṚƊ/⁼⁸

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

1= बाएँ मोड़, 0= दाएँ मोड़। मेरे Dyalog समाधान के आधार पर।

दुर्भाग्य से, जेली के नाम नहीं हैं। अगर मैं एक अंतर्निहित इनपुट का उपयोग नहीं कर सकता हूं और यह मान लेना चाहता हूं कि यह एक चर में है, तो यह समान-लंबाई संस्करण करेगा:

3RµW;®ṙN1¦ṚƊ/⁼

— आउटगोल्फर को एरिक करें
स्रोत

0

पर्ल - 120, 214

मल की एक सरणी (सूची) लेता है।

घन (120):

sub e{$a=$b=0;for$c(@_){$_=(13,62,53,40,57,26,17,'04')[$b];$d=s/$a/($b-1)%8/e;($a,$b)=($b,substr($_,$c^$d,1))}return!$b}

डोडेकेहेड्रॉन (214):

sub e{$a=$b='00';for$c(@_){$_=('01041102090307040500061807160308091502101114121019131714151016081706131819051200'=~/\d{4}/g)[$b];$d=s/$a/sprintf'%02d',($b-1)%20/e;($a,$b)=($b,substr($_,($c^$d)*2,2));}return!($b+0)}

— faubi
स्रोत

2

मैजिक नंबर एन्कोडिंग क्या हैं?

— xnor

एक चींटी एक घन पर

GolfScript, 24 वर्ण (केवल फ़ंक्शन बॉडी के लिए 19)

पर्ल, 58 वर्ण

बोनस: चींटी ऑन ए डोडेकेहेड्रॉन (गोल्फस्क्रिप्ट, 26 वर्ण)

अजगर, ६th

मेथेमेटिका

क्यूब, 51 बाइट्स

डोडेकेहेड्रोन, 55 बाइट्स

C (gcc) , 118 116 107 105 बाइट्स

अजगर - 110, 150

मारबेलस 188

पायथन 2 , 57 बाइट्स

पायथन 2 , 55 बाइट्स

हास्केल, 104 103 99 97 96/ 67 64 वर्ण

हास्केल, 64 वर्ण

हास्केल , 53 बाइट्स

APL (Dyalog Unicode) , 22 बाइट्स ( Adám's SBCS )

एपीएल (डायलॉग) , 21 बाइट्स

बैश , 71 65 बाइट्स

brainfuck , 119 बाइट्स, 137 बाइट्स

घन, 119 बाइट्स

डोडेकाहेड्रोन, 137 बाइट्स

जेली , 14 बाइट्स

पर्ल - 120, 214