Drunkard's Journey Home

In questa sfida dovrai scrivere un programma che simula un ubriacone che inciampa mentre torna a casa dal bar.

Ingresso:

L'input sarà una matrice di adiacenza (che rappresenta un grafico diretto) che rappresenta i percorsi che l'ubriacone può prendere. In ogni posizione, l'ubriacone sceglierà un percorso a caso (ogni opzione ha una probabilità approssimativamente uguale ed è indipendente dalle scelte precedenti) da seguire.

Supponiamo che l'ubriacone inizi sempre alla barra (prima riga nella matrice di adiacenza).

Se l'ubriacone entra in un vicolo cieco, si può presumere che sia tornato a casa o che sia stato arrestato per intossicazione pubblica e il programma dovrebbe tornare sul suo cammino.

Si può presumere che il grafico conterrà sempre almeno un vicolo cieco.

Si può anche presumere che l'ubriacone sarà sempre in grado di uscire dalla barra (la prima fila non sarà tutti zeri) e che se l'ubriacone fosse bloccato in una posizione, che la fila sarebbe rappresentata da tutti gli zeri.

Produzione:

L'output sarà il percorso intrapreso dall'ubriacone nel suo tentativo di tornare a casa. I valori per le posizioni possono essere zero o uno indicizzato.

Esempi:

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 byte

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

Questa funzione accetta la matrice come argomento e restituisce un elenco e utilizza l'indicizzazione 1.

L'idea di base è iniziare

{1}//.

che applica ripetutamente la regola che segue all'elenco {1}fino a quando non smette di cambiare. La regola corrisponde al modello

{r___,x_}:>

che significa "un elenco con zero o più elementi chiamati rseguito da un elemento chiamato x". Questo fornisce xl'ultimo elemento nell'elenco corrente e sostituiamo l'elenco con

{r,x,<stuff>}

che è l'elenco originale con <stuff>allegato. Il materiale in questione è

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

che prende #[[x]](il xth elemento della matrice di input) come un elenco di pesi e li mappa a n++&/@#, che è l'abbreviazione di Range@Length@#(cioè {1,2,3,...}con la lunghezza appropriata). Questo genererà un errore se i pesi sono tutti zero, motivo per cui è racchiuso in un

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

che restituirà ##&[]se viene generato un messaggio di errore. Questo è solo un modo fantasioso di scrivere Sequence[], che funge da elemento "niente" ( {1,2,Sequence[],3}valuta {1,2,3}) e quindi lascia invariato l'elenco, causando l' //.interruzione della sostituzione.

R , 72 69 66 byte

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

Provalo online!

Prende input come logicalmatrice e stampa gli indici basati su 1 sulla console.

Perl 5 -a0 , 53 51 byte

Fornisci matrice di input come stringhe strette separate su STDIN

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

Provalo online!

Danni @Fdurante il corpo del loop, ma viene riparato daredo

MATL , 15 byte

1`GyY)ft?th1ZrT

L'output è basato su 1.

Provalo online! Primo ingresso . Secondo input . Terzo input .

Spiegazione

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}

Provalo online!

Python, 136 byte

Usando l'indicizzazione zero, supponendo che la randrange sia stata importata. Accetta un input m come matrice di adiacenza

113 nessuna importazione

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 con importazioni

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

Rubino , 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]}

^{Grazie a benj2240 per aver salvato 2 byte!}

Provalo online!

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())()):[]]

Provalo online!

Versione alternativa, 81 byte

Accetta l'input come una matrice di stringhe binarie. La dimensione massima supportata è 16x16.

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

Provalo online!

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

0-indicizzato

Spiegazione:

Provalo online.

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

Provalo online!

APL (Dyalog Unicode) , 32 34 byte

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

Provalo online!

Accetta un array binario nidificato come input. Emette ciascuna iterazione su righe separate.

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]

Provalo online!

Vedi questa risposta per ulteriori spiegazioni sul generatore di numeri casuali:

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