Hành trình của Drunkard

Trong thử thách này, bạn sẽ viết một chương trình mô phỏng một người say rượu vấp ngã trên đường từ quán bar.

Đầu vào:

Đầu vào sẽ là một ma trận kề (biểu thị một đồ thị có hướng) đại diện cho các đường dẫn mà người say rượu có thể đi. Tại mỗi địa điểm, người say rượu sẽ chọn một con đường ngẫu nhiên (Mỗi tùy chọn có cơ hội xấp xỉ bằng nhau và độc lập với các lựa chọn trước) để đi theo.

Giả sử rằng người say rượu luôn bắt đầu tại quán bar (hàng đầu tiên trong ma trận kề).

Nếu người say rượu đi vào ngõ cụt, có thể giả định rằng anh ta hoặc đã về nhà hoặc bị bắt vì say công khai và chương trình sẽ quay trở lại con đường của anh ta.

Có thể giả định rằng đồ thị sẽ luôn chứa ít nhất một ngõ cụt.

Cũng có thể giả định rằng người say rượu sẽ luôn có thể thoát khỏi quán bar (hàng đầu tiên sẽ không phải là tất cả các số 0) và nếu người say rượu sẽ bị mắc kẹt ở một vị trí, thì hàng đó sẽ được đại diện bởi tất cả các số không.

Đầu ra:

Đầu ra sẽ là con đường mà người say rượu cố gắng để trở về nhà. Các giá trị cho các vị trí có thể bằng 0 hoặc một chỉ mục.

Ví dụ:

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]

Toán học, 72 byte

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

Đây là một hàm lấy ma trận làm đối số và trả về một danh sách và nó sử dụng lập chỉ mục 1.

Ý tưởng cơ bản là bắt đầu với

{1}//.

liên tục áp dụng quy tắc theo sau cho danh sách {1}cho đến khi nó ngừng thay đổi. Quy tắc khớp với mẫu

{r___,x_}:>

có nghĩa là "một danh sách có 0 hoặc nhiều phần tử được gọi rtheo sau bởi một phần tử được gọi x." Đây xlà phần tử cuối cùng trong danh sách hiện tại và chúng tôi thay thế danh sách bằng

{r,x,<stuff>}

đó là danh sách ban đầu với <stuff>phụ lục. Các công cụ trong câu hỏi là

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

trong đó lấy #[[x]]( xphần tử thứ của ma trận đầu vào) làm danh sách các trọng số và ánh xạ chúng tới n++&/@#, viết tắt của Range@Length@#(nghĩa là {1,2,3,...}có độ dài phù hợp). Điều này sẽ gây ra lỗi nếu các trọng số đều bằng 0, đó là lý do tại sao nó được bọc trong một

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

sẽ trả về ##&[]nếu một thông báo lỗi được tạo ra. Đây chỉ là một cách viết lạ mắt Sequence[], hoạt động như một yếu tố "không có gì" ( {1,2,Sequence[],3}đánh giá {1,2,3}) và do đó khiến danh sách không thay đổi, khiến việc //.dừng thay thế.

R , 72 69 66 byte

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

Hãy thử trực tuyến!

Đưa đầu vào dưới dạng logicalma trận và in các chỉ mục dựa trên 1 lên bàn điều khiển.

Perl 5 -a0 , 53 51 byte

Đưa ra ma trận đầu vào dưới dạng các chuỗi chặt chẽ riêng biệt trên STDIN

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

Hãy thử trực tuyến!

Thiệt hại @Ftrong cơ thể vòng lặp nhưng nó được sửa chữa bởiredo

MATL , 15 byte

1`GyY)ft?th1ZrT

Đầu ra là 1 dựa trên.

Hãy thử trực tuyến! Đầu vào đầu tiên . Đầu vào thứ hai . Đầu vào thứ ba .

Giải trình

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 byte

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

Hãy thử trực tuyến!

Python, 136 byte

Sử dụng lập chỉ mục bằng không, giả sử randrange đã được nhập. Lấy m đầu vào làm ma trận kề

113 không nhập khẩu

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 với hàng nhập khẩu

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

Ruby , 70 67 65 byte

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

^{Cảm ơn benj2240 vì đã tiết kiệm được 2 byte!}

Hãy thử trực tuyến!

JavaScript (ES6), 87 byte

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

Hãy thử trực tuyến!

Phiên bản thay thế, 81 byte

Đưa đầu vào như một mảng của chuỗi nhị phân. Kích thước được hỗ trợ tối đa là 16x16.

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

Hãy thử trực tuyến!

Java 10, 135 byte

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;}}

Chỉ số 0

Giải trình:

Hãy thử trực tuyến.

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 , 123 118 byte

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

Hãy thử trực tuyến!

APL (Dyalog Unicode) , 32 34 byte

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

Hãy thử trực tuyến!

Lấy một mảng nhị phân lồng nhau làm đầu vào. Xuất ra mỗi lần lặp trên các dòng riêng biệt.

Python ,97 94 byte

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]

Hãy thử trực tuyến!

Xem câu trả lời này để biết thêm giải thích về trình tạo số ngẫu nhiên:

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