एक पासा पर पासा पथ

Question

आप 2 डी ग्रिड के मूल में एक मानक डाई रखते हैं जो हर दिशा में असीम रूप से फैला हुआ है। आप डाई को ऐसे लगाते हैं कि 1 ऊपर की ओर है, 2 नकारात्मक y दिशा में सामना कर रहा है, और 3 सकारात्मक x दिशा में सामना कर रहा है, जैसा कि नीचे दिए गए चित्र में दिखाया गया है:

फिर आप इसे गति की दिशा में 90 डिग्री पर घुमाकर मरने के साथ चाल की एक श्रृंखला को अंजाम देते हैं। उदाहरण के लिए, यदि आप पहले ऋणात्मक x दिशा में डाई घुमाना चाहते थे, तो एक 3 ऊपर की ओर होगा, 2 नकारात्मक y दिशा में सामना कर रहा होगा, और एक 6 सकारात्मक x दिशा में सामना कर रहा होगा।

चालों की श्रृंखला को +y, +y, +x, +x, -yनीचे दिए गए चित्र में दिखाया गया है, साथ ही स्पष्टीकरण के लिए डाई का जाल (कभी-कभी नेट को 'राइट-हैंडेड डाई' कहा जाता है)।

हम हर कदम के बाद मरने के शीर्ष चेहरे को पढ़ने के लिए आगे बढ़ते हैं। इस मामले में, यह पढ़ा जाएगा 2, 6, 4, 1, 2, जिसे हम पासा पथ कहते हैं । ध्यान दें कि हम अपनी प्रारंभिक स्थिति में मरने के शीर्ष चेहरे को शामिल नहीं करते हैं, लेकिन यह हमेशा 1 होता है।

अगर मरने का रास्ता ऐसा है कि वह अपने आंदोलन के अंत में शुरू होने वाले वर्ग में लौटता है, तो हम इसे एक पासा मार्ग कहते हैं जो मूल पर लौटता है ।

चुनौती

इनपुट के रूप में एक गैर-खाली पासा पथ (एक सूची या किसी अन्य उचित प्रारूप में) को देखते हुए, यदि पासा पथ मूल में लौटता है, और एक मिथ्या मूल्य अन्यथा, एक सत्य मान प्रिंट करें। ध्यान दें कि:

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

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

Path                            -> Output
2,1                             -> true
3,1                             -> true
5,4,1,5                         -> true
2,4,1,2                         -> true
4,2,4,1                         -> true
2,4,6,2,4,6,5,4                 -> true
2,4,5,1,4,5,3,6,5,1             -> true
5,6,2,3,5,4,6,3,1,5,6,2         -> true
2,4,1,3,5,1,3,5,6,3,5,6,4,5,6,2 -> true
2                               -> false
4,5                             -> false
5,1,2                           -> false
5,6,2,1                         -> false
5,4,6,5,4,6                     -> false
5,6,4,1,5,4,2,6,5,4             -> false
5,1,2,1,5,6,5,1,2,6,4           -> false
4,6,3,1,5,6,2,1,3,6,4,1         -> false

स्कोरिंग

बाइट्स में सबसे छोटा कोड जीतता है।

Answer 1

जावास्क्रिप्ट (ईएस 6),  142 ... 122  121 बाइट्स

वर्णों की एक सरणी की अपेक्षा करता है, जैसे ['5','1','2']। रिटर्न 0 या 1 ।

a=>a.map(n=>D=D.map((_,i)=>D['504405076067'[d*6+i>>1]^i],p+=[w=a.length,-w,1,-1][d=D.indexOf(n)]),p=0,D=[...'254316'])|!p

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

कैसे?

सरणी D[]निम्न क्रम में अंकित मान रखती है:

 index |    0   |    1   |    2   |    3   |    4   |    5
-------+--------+--------+--------+--------+--------+--------
 face  |  front | behind |  left  |  right |   top  | bottom

हम शुरू करते हैं D = ['2','5','4','3','1','6'], जो इस एन्कोडिंग का उपयोग करते हुए चुनौती में वर्णित मौत का प्रारंभिक अभिविन्यास है।

dअगले कदम की दिशा नए शीर्ष चेहरे की 0-अनुक्रमित स्थिति है D[]:

 index (d) |   0   |   1   |   2   |   3
-----------+-------+-------+-------+-------
 direction |  up   |  down | right |  left

दिशा की ओर बढ़ते समय d, iअद्यतित डाई में -थे चेहरा, पिछली डाई में निम्न स्थिति में होता है:

   i = | 0 | 1 | 2 | 3 | 4 | 5
-------+---+---+---+---+---+---
 d = 0 | 5 | 4 | 2 | 3 | 0 | 1
 d = 1 | 4 | 5 | 2 | 3 | 1 | 0
 d = 2 | 0 | 1 | 5 | 4 | 2 | 3
 d = 3 | 0 | 1 | 4 | 5 | 3 | 2

यह तालिका निम्नलिखित अभिव्यक्ति के साथ एन्कोडेड है:

'504405076067'[d * 6 + i >> 1] ^ i

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

प्रत्येक पुनरावृत्ति पर, हम अद्यतन करते हैं D[]और स्थिति p। हम जोड़ने के \$\pm 1\$से \ _$p\$क्षैतिज रूप से आगे बढ़ने पर, या \ _$\pm w\$जब लंबवत चलती है, जहां \$w\$इनपुट सरणी की लंबाई (दूरी की एक ऊपरी सीमा है जिसे एक ही दिशा में यात्रा की जा सकती है)। हम परीक्षण करते हैं कि क्या हम प्रक्रिया के अंत में अपने शुरुआती बिंदु पर वापस आ गए हैं।

Answer 2

जे , 79 बाइट्स

बॉक्स 0 से 5 की उलटी सूची के रूप में पासा मार्ग में ले जाता है।

0 0-:[:+/(0,(,-@|.)=i.2){~]i.~&>[:}.(]A.~0 224 283 389 489{~i.~)&.>/\.@,&(<i.6)

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

यह काम किस प्रकार करता है

हमारे पास सूची के रूप में शुरुआती पासा है 0 1 2 3 4 5। अगले शीर्ष अंक की तलाश में, हमारे पास या तो 1 2 3 4इसके सूचकांक के रूप में है ( 0और 5अवैध कदम होंगे)। विपर्यय सूचकांकों को लेते हुए 224 283 389 489हम सूची को अनुमति देते हैं, एक पासा कदम को निष्पादित करते हैं। हम पूरे रास्ते के लिए ऐसा करते हैं और मध्यवर्ती परिणाम इकट्ठा: 0 1 2 3 4 5│4 0 2 3 5 1│3 0 4 1 5 2। फिर से, सूचकांकों की तलाश के बाद, हम उन्हें समन्वय परिवर्तनों के लिए मैप करते हैं _1 0, 0 _1, 1 0, 0 1, उन्हें जोड़ते हैं और जांचते हैं कि क्या वे अंत में हैं 0 0।

6 से 4, 5 से 3,…, 1 से 5 को दो डमी शून्य ( 0,और 0 ) को बचाने के लिए संभावित सूचकांकों को स्थानांतरित करके बाइट की बचत होनी चाहिए 0 1 2 3। लेकिन यह इतना गलत लगता है कि मैं पहले एक और समाधान के बारे में सोचने की कोशिश करूंगा। :-)

Answer 3

चारकोल , 55 48 बाइट्स

≔324516θＦＳ«≔⌕θιιＭ✳⊗ι≔⭆§⪪”)⊟？2p}Þ↔～>”⁶ι§θＩκ軬∨ⅈⅉ

इसे ऑनलाइन आज़माएं! लिंक कोड के वर्बोज़ संस्करण के लिए है। अंकों के एक तार के रूप में इनपुट लेता है और चारकोल बूलियन को आउटपुट करता है, यानी -मूल पर वापस, व्हॉट्सएप यदि नहीं (+2 बाइट्स को व्हाट्सएप को हटाने के लिए)। स्पष्टीकरण:

≔324516θ

मरने पर अंक, दाएं, ऊपर, बाएं, नीचे, ऊपर, नीचे क्रम में।

ＦＳ«

इनपुट अंकों के माध्यम से लूप।

≔⌕θιι

किस दिशा में मरो लुढ़काया गया था।

Ｍ✳⊗ι

उस दिशा में आगे बढ़ें।

≔⭆§⪪”)⊟？2p}Þ↔～>”⁶ι§θＩκ軬∨ⅈⅉ

514302 052413 415320 042531दिशा के आधार पर एक लुकअप तालिका का उपयोग करके अपने नए पदों पर अंकों की अनुमति दें ।

»¬∨ⅈⅉ

क्या हम मूल पर वापस समाप्त हो गए?

Answer 4

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

a=b=1
t=0
for c in input():t=1+t*1j**(a*c*(a*a-c*c)*b**5%7*2/3+2*(a==c));a,b=b,c
print t==0

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

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

इसे इस तरह से करने का अर्थ है कि हमें स्वयं मरने की स्थिति को ट्रैक करने की आवश्यकता नहीं है - बस इनपुट अनुक्रम के स्थानीय स्निपेट को देखना होगा। हम किसी भी हार्डकोड मान या मैजिक नंबर का उपयोग नहीं करते हैं।

मुश्किल बिट तीन लगातार मरने वाले चेहरे से बारी दिशा निकाल रहा है। आप इन्हें पहले चेहरे से दूसरे चेहरे पर रेंगने वाले बग के रूप में सोच सकते हैं, और फिर दूसरे चेहरे से तीसरे चेहरे पर - ऐसा करने के लिए किस दिशा में दूसरे चेहरे को चालू करने की आवश्यकता है? हम यह पता लगा सकते हैं कि यदि पहला और तीसरा चेहरा बराबर है, तो यह दोगुना हो जाता है और यह पहला और तीसरा चेहरा विपरीत होने पर सीधे आगे बढ़ जाता है, इसलिए वे 7 में जुड़ जाते हैं।

शेष मामलों में, यह पता लगाने के लिए रहता है कि बग दाएं से बाएं मुड़ता है या नहीं, चेहरे का त्रिभुज बाएं हाथ या दाएं हाथ से है। इसके लिए, हम अपने सीडब्ल्यू समाधान से साइड व्यू से डाइस मान निर्धारित करने के लिए एक बीजगणितीय चाल उधार लेते हैं । त्रिभुज दाएं हाथ या बाएं हाथ के आधार पर अभिव्यक्ति या 3*a*c*(a*a-c*c)तो 7 bया -bmodulo 7 के बराबर होगी । वहां से, कुछ मालिश बारी दिशाओं के चार मामलों को संख्याओं के बराबर ले जाती है जो कि 0,1,2,34 modulo के बराबर होती है , ताकि हम जटिल घातांक का उपयोग करके सही जटिल घुमाव प्राप्त कर सकें 1j**।

Answer 5

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

6RW;⁸œ?@\ḊḢ€⁼
“§ṫ²G‘×J$ṗLçƇ:19Ḣı*S¬

एक मोनडिक लिंक पासा-पाथ को चेहरे की एक सूची के रूप में स्वीकार कर रहा है $ \ _ [1,6] \ $ जो पैदावार 1(सत्य) देता है यदि यह शुरू में वापस समाप्त होता है, या 0(झूठी)।

इसे ऑनलाइन आज़माएं! या परीक्षण-सूट देखें (विधि सबसे अक्षम होने के बाद 6 सबसे लंबे समय तक हटाया गया)।

कैसे?

दिए गए पासा-पथ की लंबाई के सभी संभावित रास्तों को अगले राज्य के क्रमपरिवर्तन-सूचकांकों के रूप में चार संभावित दिशाओं से बनाया गया है।
दिए गए पासा-पथ में फेस-अप संख्याओं से मेल खाने वाले को खोजने के लिए इन्हें फ़िल्टर करता है।
जटिल संख्याओं के रूप में क्रमबद्धन सूचकांकों को चार कार्टेशियन दिशाओं में अनुवाद करता है।
जाँच करता है कि क्या इनका योग शून्य है।

“§ṫ²G‘×J$ṗLçƇ:19Ḣı*S¬ - Main Link: dice-path
“§ṫ²G‘                - list of code-page indices = [225,245,130,71]
      ×J$             - multiply by their indices = [225,490,390,284]
                        (these correspond to [up, down, right, left])
          L           - length (of the dice-path)
         ṗ            - Cartesian power (all lists of that length using {225,490,390,284})
            Ƈ         - filter keep those for which:
           ç          -   call Link 1 as a dyad - f(potential-path, dice-path)
             :19      - integer divide by 19 (225,490,390,284 -> 11,25,20,14)
                Ḣ     - head (get the single path that filering found)
                        (having Ḣ here rather than before the :19 saves a byte)
                 ı*   - i exponentiate (that) (11,25,20,14 -> -i,i,1,-1)
                        (yep we've mirrored but it makes no difference)
                   S  - sum
                    ¬ - logical NOT

6RW;⁸œ?@\ḊḢ€⁼ - Link 1: potential-path (as permutation indices), dice-path
6             - six
 R            - range -> [1,2,3,4,5,6]
  W           - wrap -> [[1,2,3,4,5,6]]
   ;⁸         - concatenate with the permutation indices -> [[1,2,3,4,5,6],a,b,c,...]
        \     - cumulative reduce (current-state, permuation index) by:
       @      -   with swapped arguments:
     œ?       -     permuation (of the current state) at index (permutation index)
         Ḋ    - dequeue (remove the leading [1,2,3,4,5,6])
          Ḣ€  - head of each (get the list of face-up pips)
            ⁼ - equals (the dice-path)?

Answer 6

पायथन 3 , ^{174 \$\cdots\$ 130} 129 बाइट्स

एक भारी 15 30 35 बाइट्स आदमी खुद Arnauld के लिए धन्यवाद सहेजा !!! अंडा के लिए
एक और whopping 3 9 10 बाइट्स धन्यवाद !!!

def f(l,p=[3,2,4,5,1,6],v=0):
 for d in l:n=p.index(d);v+=1j**n;p=[p[int(i)]for i in'%06d'%ord('񽣾첽񥙘꘣'[n])]
 return v==0

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

रिटर्न Trueअगर हम वापस मूल में या अंत Falseअन्यथा।

पोर्ट ऑफ नील के चारकोल उत्तर का उपयोग जटिल अंकगणित का उपयोग करके पता लगाने के लिए कि क्या हम वापस आ गए हैं जहां हमने शुरू किया था।

Answer 7

आर , 143 ... 116 102 बाइट्स

संपादन: -13 बाइट्स मैट्रिक्स की ट्रांज़िशन सूची की बजाय रैखिक पर स्विच करके, फिर -4 बाइट्स ट्रांज़िशन की सूची को रोक कर और प्रत्येक रोल पर दाएं, सामने और शीर्ष मानों को 7 शून्य मानकर बाईं, पीछे और नीचे मरने के मूल्यों की गणना करके। फिर -3 बाइट्स को संक्रमण की सूची उत्पन्न करने के लिए आधार -7-एन्कोडेड नंबर पर स्विच करके, फिर -14 बाइट्स को संक्रमण की सूची को ऊपर, दाएं, नीचे, बाएं से विभाजित करके नई स्थिति की गणना करना आसान बनाता है, ताकि मैं की शक्तियों का उपयोग कर आसान कर सकूं। और -6 बाइट विभिन्न अन्य छोटे गोल्फों द्वारा किया गया जो दृष्टिकोण में परिवर्तन नहीं करते थे

p=a=1:4;m=5032105982%/%7^(11:0)%%7;for(i in scan()){p[6:4]=7-p;p=p[m[q<-(p[m[a]]==i)]];F=F+1i^a[q]};!F

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

कैसे?

(गोल्फिंग से पहले टिप्पणी कोड)

is_dice_loop=
function(s,                     # s = vector of top die values along path
 p=1:6,                         # p = positions of current die values
                                #     (top,front,right,left,back,bot)
 m=matrix(                      # m = matrix of transitions at each roll
  utf8ToInt(                    #     created from ASCII values of
   "bedcfabbccafddfaafeeebcd")  #     this string
   -96,                         #     -96,
  4)                            #     matrix has 4 rows.
 ){
 for(i in s){                   # Now, for each die value i along the path
  r=match(i,p[m[,1]]);          #  calculate the roll direction r
                                #  (1:4 -> up,down,right,left),
  p=p[m[r,]];                   #  then calculate the new positions of die values,
  F=F+(-.5+r%%2)*1i^(r>2)       #  and calculate the new location of the die
                                #  as a complex number (real=left->right, imaginary=down->up)
                                #  (F is initialized as 0+0i by default).
 }
 !F                             # If we end up back at 0+0i, then we've done a loop,
}                               # so NOT F is true.  

Answer 8

वोल्फ्राम लैंग्वेज (गणितज्ञ) , 96 91 83 74 बाइट्स

<<Quaternions`
0==Tr[a={-1,-K,J,-J,K,1};(a=#**a**#/2;#-1)&[1+a[[#]]]&/@#]&

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

Quaternions` फ़ंक्शन परिभाषा से पहले लोड किया जाना चाहिए।

<<Quaternions`          (* load the Quaternions` package *)
a={-1,-K,J,-J,K,1};     (* (a die roll of i moves the die in direction a[[i]]) *)
(a=#**a**#/2;#-1)&      (* rotate `a` in a direction, returning the direction, *)
% [1+a[[#]]]&/@#        (* taking directions one at a time from input. *)
0==Tr[ % ]&             (* check if sum of those directions returns to the origin. *)

Answer 9

पर्ल 5 -pF , 130 , 121 बाइट्स

@A=(2,4,-1,1,-@F,@F+!s/^/1/);s/.(?=.(.))/$x+=$A[$&==$1||$&+$1!=7&&($P[$|--]=$&)&&$1==$P[$|]?$A[$|]^=1:$A[$|]]/ge;$_=$x==1

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

एक अलग समाधान, सीधा एक 173 बाइट्स था , जिसे 165 बाइट्स के लिए गोल्फ किया जा सकता था ।

संपादित करें: मुझे एहसास हुआ कि सीधा करने के लिए 136 बाइट्स के लिए गोल्फ हो सकता है

लेकिन गोल्फ के लिए मैं अधिक हालांकि अलग है। इस तथ्य का उपयोग करना कि विपरीत पक्ष का योग 7. है और दिशाओं को प्राप्त करने के लिए कुछ पिछली संख्या पर नज़र रखना पर्याप्त हो सकता है।

• सरणी A:
  • [0]= {2 | 3} और [1]= {4 | 5}: (+/-) x या (+/-) y पर दिशा को संग्रहीत करने के लिए, जहां x और y इन अक्षों पर पहली चाल की दिशा पर निर्भर करते हैं
  • अगला [2..5]: $xदिशा के अनुरूप जोड़ने के लिए संख्याओं को संग्रहीत करना
• s/^/1/: 1प्रारंभिक चेहरे को प्रीपेन्ड करें
• रेगेक्स .(?=.(.)): एक डाई चेहरे की खपत करता है $&और अगले अगले पर कब्जा करता है$1
• $&==$1 दिशा बदल रही है
• $&+$1==7 दिशा नहीं बदलती है, परीक्षण उलटा है क्योंकि कुछ भी नहीं करना है
• अन्यथा दिशा पहले की दिशा की तुलना में कठोरता या बाईं ओर बदल गई है
• सरणी P: अंतिम डाई चेहरे को संग्रहीत करता है [0] x, [1] y, जहां x और y पहली चाल पर निर्भर करते हैं
  • $P[$|--]=$& :
    • $P[$|]=$& मरने के चेहरे को स्टोर करने के लिए जब बाएं या दाएं मुड़ते हैं
    • $|-- x / y के लिए अक्ष सूचकांक 0/1 स्विच करता है
• $1==$P[$|] अगले अगले चेहरे की तुलना पिछले से की जाती है जब एक ही धुरी पर चलती है यदि दिशा समान होती है तो पिछली दिशा की तुलना में पीछे की ओर बदल रही है
• ^=1 : bytwise xor (2 <-> 3) या (4 <-> 5) का उपयोग कर स्विच करने के लिए
• $_=$x==1: प्रारंभिक स्थिति जब $x==1पहली चाल (दिशा 2: -1) नहीं जोड़ी गई थी।