醉汉之旅之家

在这个挑战中，您将要编写一个程序，模拟一个酒鬼从酒吧回家的途中。

输入：

输入将是一个邻接矩阵（表示一个有向图），该矩阵表示酒鬼可以采取的路径。在每个位置，酒鬼都会随机选择一条路径（每个选项的机会大致相等，并且与先前的选择无关）。

假设酒鬼总是从柱子开始（邻接矩阵的第一行）。

如果酒鬼陷入死胡同，可以认为他要么回家了，要么因公共陶醉而被捕，程序应该返回他的路。

可以假设该图将始终包含至少一个死角。

还可以假定酒鬼将始终能够退出酒吧（第一行将不全为零），并且如果酒鬼将卡在某个位置，则该行将用全零表示。

输出：

输出将是酒鬼试图回家的道路。位置的值可以为零或一个索引。

例子：

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]

Mathematica，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输入矩阵的第th个元素）作为权重列表并将其映射到n++&/@#，这是权重的缩写Range@Length@#（即{1,2,3,...}具有适当的长度）。如果权重全为零，则将引发错误，这就是为什么将其包装在

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

##&[]如果生成错误消息，它将返回。这只是一种奇特的书写方式Sequence[]，它充当“ nothing”元素（{1,2,Sequence[],3}计算为{1,2,3}），因此使列表保持不变，从而导致//.停止替换。

R，72 69 66字节

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

在线尝试！

将输入作为logical矩阵，并将基于1的索引打印到控制台。

Perl 5中 -a0，53 51个字节的

在STDIN上将输入矩阵作为单独的紧字符串

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

在线尝试！

@F环体损坏，但可通过以下方式修复redo

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

Perl 6、38个字节

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

在线尝试！

Python，136个字节

使用零索引，假设已导入randrange。将输入m作为邻接矩阵

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

红宝石，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]}

^{感谢benj2240节省了2个字节！}

在线尝试！

JavaScript（ES6），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())()):[]]

在线尝试！

Java 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)

Haskell，123118字节

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#)

在线尝试！

APL（Dyalog Unicode），32 34字节

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

在线尝试！

将嵌套的二进制数组作为输入。在单独的行上输出每个迭代。

Python，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