ड्रंकर्ड जर्नी होम

Question

ड्रंकर्ड जर्नी होम

इस चुनौती में आपको एक प्रोग्राम लिखना है जो एक शराबी को बार से घर के रास्ते से ठोकर मारता है।

इनपुट:

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

मान लें कि शराबी हमेशा पट्टी पर शुरू होता है (आसन्न मैट्रिक्स में पहली पंक्ति)।

यदि शराबी एक मृत-अंत में प्रवेश करता है, तो यह माना जा सकता है कि उसने या तो घर पर अपना रास्ता बना लिया है या उसे सार्वजनिक नशा करने के लिए गिरफ्तार किया गया है और कार्यक्रम को अपना रास्ता लौटाना चाहिए।

यह माना जा सकता है कि ग्राफ़ में हमेशा कम से कम एक डेड-एंड होगा।

यह भी माना जा सकता है कि शराबी हमेशा बार से बाहर निकलने में सक्षम होगा (पहली पंक्ति सभी शून्य नहीं होगी) और यह कि अगर शराबी एक स्थान पर फंस जाएगा, तो पंक्ति को सभी शून्य द्वारा दर्शाया जाएगा।

आउटपुट:

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

उदाहरण:

Input
[1,0,1,1]
[0,0,0,0]
[1,0,0,0]
[1,1,1,1]

Possible Outputs
[0,2,0,3,2,0,0,3,1]
[0,3,0,3,1]


Input
[0,1,1,1,0,1]
[1,0,1,0,1,1]
[0,0,0,0,0,0]
[0,0,0,0,0,1]
[1,0,0,0,0,0]
[0,0,0,0,0,0]

Possible outputs
[0,1,5]
[0,5]
[0,1,4,0,2]
[0,3,5]
[0,3,0,1,4,0,5]

Deterministic path:

Input
[0,0,1,0]
[0,0,0,1]
[0,1,0,0]
[0,0,0,0]

Output
[0,2,1,3]

Comments

यह कुछ छात्र यादों को वापस लाता है ... मेरा मतलब है, इरेटी, मैं निश्चित रूप से निर्देशित रेखांकन के बारे में बात कर रहा हूं! o :-)

— अरनौलड

क्या हम इनपुट को स्ट्रिंग्स की एक सरणी के रूप में ले सकते हैं [ '1011', '0000', '1000', '1111' ]?

— अरनुलद

क्या बार के लिए एक मृत अंत होना संभव है? दूसरे शब्दों में, क्या पहली पंक्ति कभी सभी शून्य होगी? इसके अलावा, क्या कभी कोई ऐसी पंक्ति होगी जो केवल खुद को आगे बढ़ाती है, और क्या हमें इसका पता लगाना होगा कि अंतिम स्थिति के रूप में? दूसरे शब्दों में, क्या iस्तंभ पर छोड़कर सभी शून्य के साथ एक पंक्ति होगी i?

— kamoroso94

मैं बस किसी का इंतजार कर रहा हूं टैक्सी में एक जवाब लिखने के लिए

— बेल्लाबाद

2 उदाहरण में आपको अंतिम रास्ता कैसे मिलता है? मेरी समझ से, के लिए 0लिंक 1,2,3,5, लेकिन पिछले उत्पादन से यह जा रहा 0है4

— फाफैक

Answer 1

गणितज्ञ, 72 बाइट्स

{1}//.{r___,x_}:>{r,x,n=1;Check[RandomChoice[#[[x]]->(n++&/@#)],##&[]]}&

यह एक फ़ंक्शन मैट्रिक्स को एक तर्क के रूप में लेता है और एक सूची लौटाता है, और यह 1-इंडेक्सिंग का उपयोग करता है।

मूल विचार के साथ शुरू करना है

{1}//.

जो बार-बार नियम को लागू करता है जो सूची में {1}तब तक चलता है जब तक कि वह बदलना बंद न कर दे। नियम पैटर्न से मेल खाता है

{r___,x_}:>

जिसका अर्थ है "शून्य या अधिक तत्वों वाली एक सूची जिसे rएक तत्व कहा जाता है x।" यह xवर्तमान सूची में अंतिम तत्व के रूप में देता है , और हम सूची को प्रतिस्थापित करते हैं

{r,x,<stuff>}

जो मूल सूची में <stuff>संलग्न है। प्रश्न में सामान है

RandomChoice[#[[x]]->(n++&/@#)]

जो लेता है #[[x]]( xवजन की एक सूची के रूप में इनपुट मैट्रिक्स के वें तत्व) और उन्हें नक्शे के लिए n++&/@#, जिसके लिए कम है Range@Length@#(यानी {1,2,3,...}उचित लंबाई के साथ)। यह एक त्रुटि को फेंक देगा यदि वजन सभी शून्य हैं, यही वजह है कि यह एक में लपेटा गया है

Check[...,##&[]]

जो ##&[]एक त्रुटि संदेश उत्पन्न होने पर वापस आ जाएगा । यह केवल लेखन का एक फैंसी तरीका है Sequence[], जो एक "कुछ भी नहीं" तत्व ( {1,2,Sequence[],3}मूल्यांकन {1,2,3}) के रूप में कार्य करता है और इसलिए सूची को अपरिवर्तित छोड़ देता है, जिससे //.प्रतिस्थापित करना बंद हो जाता है।

Answer 2

आर , 72 69 66 बाइट्स

function(m,o=1)while({print(o);any(x<-m[o,])})o=sample(which(x),1)

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

एक logicalमैट्रिक्स के रूप में इनपुट लेता है , और 1-आधारित सूचकांकों को कंसोल पर प्रिंट करता है।

Answer 3

पर्ल 5 -a0 , 53 51 बाइट्स

STDIN पर अलग से तंग तारों के रूप में इनपुट मैट्रिक्स दें

$!/usr/bin/perl -a0
$n=!say$%;$F[$%]=~s:1:($%)=@-if 1>rand++$n:eg&&redo

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

@Fपाश शरीर के दौरान नुकसान लेकिन यह द्वारा मरम्मत की जाती हैredo

Answer 4

MATL , 15 बाइट्स

1`GyY)ft?th1ZrT

आउटपुट 1-आधारित है।

इसे ऑनलाइन आज़माएं! पहला इनपुट । दूसरा इनपुट । तीसरा इनपुट ।

व्याख्या

1          % Push 1: initial value of current row index
`          % Do...while
  G        %   Push input matrix
  y        %   Duplicate from below: pushes copy of current row index
  Y)       %   Get that row
  f        %   Find: push (possibly empty) array of indices of non-zero entries
  t        %   Duplicate
  ?        %   If non-empty
    th     %     Attach a copy of itself. This is needed in case the array
           %     contains a single number n, because then the randsample
           %     function would incorrectly treat that as the array [1 2 ... n]
    1Zr    %     Randsample: pick 1 entry at random with uniform probability
    T      %     Push true
           %   End (implicit)
           % End (implicit). Proceed with a new iteration if the top of the
           % stack is truthy. This happens if the current row had some
           % non-zero entry, in which case true was pushed (and is now
           % consumed). If the current row was all zeros, the top of the stack
           % is an empty array that was produced by the find function, which is
           % falsy (and is also consumed now). In that case the loop is exited,
           % and then the stack contains a collection of numbers which
           % collectively describe the path
           % Implicit display

Answer 5

पर्ल 6 , 38 बाइट्स

{0,{.[$^l].grep(?*,:k).roll}...^!*.kv}

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

Answer 6

पायथन, 136 बाइट्स

शून्य अनुक्रमण का उपयोग करते हुए, मान लें कि रैंड्रेंज को आयात किया गया है। आसन्न मैट्रिक्स के रूप में एक इनपुट मी लेता है

113 कोई आयात नहीं

s=lambda m,c=0,p=[0],x=0:1 in m[c]and(m[c][x]and s(m,x,p+[x],randrange(len(m)))or s(m,c,p,randrange(len(m))))or p

आयात के साथ 136

import random as r;s=lambda m,c=0,p=[0],x=0:1 in m[c]and(m[c][x]and s(m,x,p+[x],r.randrange(len(m)))or s(m,c,p,r.randrange(len(m))))or p

Comments

मैं आपकी मुख्य बाइट गिनती के रूप में 136 का उपयोग करने की सिफारिश करूंगा, जैसा कि सर्वसम्मति से आयात बयानों के अनुसार होता है।

— जोनाथन फ्रीच

Answer 7

रूबी , 70 67 65 बाइट्स

f=->m,i=0{m[i].sum<1?[]:m[i][x=rand(m.size)]<1?f[m,i]:[x]+f[m,x]}

^{2 बाइट बचाने के लिए benj2240 के लिए धन्यवाद !}

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

Comments

आप कुछ बाइट्स बचा सकते हैंm[i].sum<1?:[]

— benj2240

@ benj2240 वाह, मुझे कभी नहीं पता था कि यह संभव है। अब मुझे एहसास हुआ कि .sum2.4 में पेश किया गया था। मैं करता था .reduce(0, :+)...

— क्रिस्टियन लुपस्कु

Answer 8

जावास्क्रिप्ट (ईएस 6), 87 बाइट्स

f=(a,y=0)=>[y,.../1/.test(r=a[y])?f(a,(g=_=>r[k=Math.random()*r.length|0]?k:g())()):[]]

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

---

वैकल्पिक संस्करण, 81 बाइट्स

बाइनरी स्ट्रिंग्स की एक सरणी के रूप में इनपुट लेता है। अधिकतम समर्थित आकार 16x16 है।

f=(a,y=0)=>[y,...+(r=a[y])?f(a,(g=_=>+r[k=Math.random()*r.length|0]?k:g())()):[]]

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

Answer 9

जावा 10, 135 बाइट्स

m->{var R="0 ";for(int r=0,c,t;;R+=(r=c)+" "){t=0;for(int x:m[r])t+=x;if(t<1)return R;for(t=c=m.length;m[r][c*=Math.random()]<1;)c=t;}}

0 अनुक्रमित

स्पष्टीकरण:

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

m->{                   // Method with integer-matrix parameter and String return-type
  var R="0 ";          //  Result-String, starting at "0 "
  for(int r=0,         //  Row-integer, starting at 0
          c,           //  Column-integer
          t;           //  Temp-integer
      ;                //  Loop indefinitely
       R+=             //    After every iteration: Append the result with:
          (r=c)+" "){  //     The current column and a delimiter-space,
                       //     And set the current row to this column at the same time
    t=0;               //   (Re-)set `t` to 0
    for(int x:m[r])    //   Loop over the values of the current row
      t+=x;            //    And add them to `t`
    if(t<1)            //   If the entire row only contained zeroes:
      return R;        //    Return the result
    for(t=c=m.length;  //   Set `t` (and `c`) to the size of the matrix
        m[r][c*=Math.random()]<1;)
                       //   Loop until we've found a 1,
                       //   picking a random column in the range [0,`c`)
      c=t;}}           //    Reset the range of `c` to `t` (the size of the matrix)

Answer 10

हास्केल , 123 118 बाइट्स

import System.Random
i#m|sum(m!!i)<1=pure[]|1<2=do{x<-randomRIO(0,length m-1);[i#m,x#m>>=pure.(x:)]!!(m!!i!!x)}
f=(0#)

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

Answer 11

एपीएल (डायलॉग यूनिकोड) , 32 34 बाइट्स

t←⎕
{}{s[?≢s←⍸⍵⊃t]}⍣{~0∊t⊃⍨⎕←⍵}1

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

इनपुट के रूप में एक नेस्टेड बाइनरी सरणी लेता है। अलग-अलग लाइनों पर प्रत्येक पुनरावृत्ति को आउटपुट करता है।

Answer 12

अजगर ,97 94 बाइट्स

f=lambda a,i=0,j=0:sum(a[i])and[i]*a[i][j]+f(a[:],(i,j)[a[i][j]],id(a)**7%~-2**67%len(a))or[i]

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

---

यादृच्छिक संख्या जनरेटर के बारे में अधिक स्पष्टीकरण के लिए यह उत्तर देखें :

id(a)**7%~-2**67