Disegna un programma o una funzione che scriverà a STDOUT nvolte (ciascuno per un passaggio) una stringa che contiene un punto .nella posizione del walker. Inoltre, il programma deve scrivere una riga ogni ssecondo (o attendere ssecondi dopo ogni riga).

Una passeggiata casuale è una formalizzazione matematica di un percorso che consiste in una successione di passi casuali ( wiki ), in modo tale che ogni nuovo passo sarà l'ultimo passo più un nuovo valore, quindi qualsiasi tvalore di passo è solo la somma di tutti i valori casuali prima di ir più il valore iniziale.

Il programma dovrebbe prendere 2 input e utilizzerà solo spazi " "e punti "."sull'output. Il valore iniziale del walker sarà 20tale che l'output dovrebbe essere un punto dopo 19 spazi.

                  . #19 spaces then a dot

Ad ogni nuovo passaggio il valore sarà l'ultimo valore del walker più uno di questi [-2-1,0,1,2](20% di probabilità ciascuno). Dopo aver stampato la nuova posizione, il programma dovrebbe attendere alcuni ssecondi e andare al passaggio successivo. Se il passaggio porta il camminatore fuori dalla portata 1 to 40, dovrebbe essere semplicemente ignorato e la posizione del camminatore rimane invariata. Il numero di spazi sarà sempre un numero compreso tra 0 e 39.

Esempio

#input
Mywalk(s = 0.1, n = 30)

#output
                     .
                    .
                      .
                        .
                          .
                           .
                            .
                          .
                         .
                          .
                           .
                            .
                           .
                          .
                           .
                           .
                         .
                         .
                          .
                            .
                           .
                          .
                           .
                           .
                           .
                         .
                          .
                         .
                          .
                          .

considerazioni

• È possibile accettare l'input in qualsiasi formato ragionevole

• Vince il codice più corto

• Va bene se il tuo programma accetta solo i secondi come numeri interi

Pyth, 39

J19VEK+.d0QW<.d0K)+*d=JhtS[Z39-+O5J2)\.

Prende scome prima riga di input e ncome seconda. Funziona sulla riga di comando ma non con l'interprete online. Il mio primo programma Pyth di sempre! I consigli sul golf sono apprezzati.

Matlab, 112

L'idea di base è generare un elenco di possibili posizioni successive e quindi disegnarne uniformemente una. Se ci troviamo ad esempio nella posizione $ l = 1 $, i passi possibili sarebbero [-1,0,1,2,3]ovviamente se lo sceglieremo-1 che non sarebbe valido e dovremmo rimanere nella stessa posizione. Ecco perché sostituiamo le posizioni non valide con la posizione corrente [1,0,1,2,3], e quindi abbiamo scelto casualmente un elemento da questo elenco aggiornato.

L'OP ci ha chiesto di disegnare il programma, quindi eccoci qui:

La trascrizione:

function c(n,s);
l=19;                             %initialize position
for k=1:n;                          
    disp([ones(1,l)*32,'.']);     %print the line
    z=(-2:2)+l;                   %get vector of possible next steps (for l=1 we get [-1,0,1,2,3])
    z(z<0)=l;                     %prune invalids: here we just replace the the invalid positions with the current position
    z(z>39)=l;                    %   this ensures the same behaivour as staying in the same spot when going outside of the range
    l=z(randi(5));                %draw random sample of those
    pause(s);
end

Perl, 136 128 116 106 101 90 86

$p=19;map{say$"x$p.".";sleep $ARGV[0];$x=rand(5)+$p-2;$p=$x>0&&$x<40?$x:$p}1..$ARGV[1]

Richiede che i secondi siano un numero intero.

Corri con perl <filename> <second delay> <number of steps>.

Potrebbe esserci più potenziale per il golf qui, anche se onestamente, sono sorpreso che sia arrivato così lontano. (Dai, solo altri 6 byte per battere la risposta bash ...)

I cambiamenti

• Salvato 8 byte rimuovendo le parentesi non necessarie e precisando ARGV (in realtà è più breve in quel modo)
• Abbiamo salvato altri 12 byte rimuovendo $se $nusando semplicemente il tasto $ARGV[0]e$ARGV[1]
• Ho salvato altri 10 byte quando ho capito che potevo usare $"e non avevo bisogno di definire $ucome $undef.
• Hai salvato altri 5 byte riorganizzando il ternario e come $xviene usato e usando mapinvece di for.
• Salvato 11 byte non accettando più i secondi come decimali (la specifica della sfida dice che va bene.)
• Salvati altri 5 byte usando sayinvece di print.

Python 2, 124 119 byte

@janrn e @Steve Eckert: non ho abbastanza reputazione per commentare la tua risposta, ma qui essenzialmente la tua versione abbreviata. Il compito è disegnare un programma o una funzione , quindi usando f(s,x)puoi salvare parecchi bit, e puoi anche usare max(0,min(x,39))per evitare una ifclausola aggiuntiva . Ho capito:

import time,random as r
def f(s,x):
 n=19
 while x:print' '*n+'.';time.sleep(s);n=max(0,min(n+r.randint(-2,2),39));x-=1

Bash, 81

for((s=20;i++<$1;t=s,s+=RANDOM%5-2,s=s<0|s>39?t:s)){
printf %${s}s.\\n
sleep $2
}

Modifica: se il passaggio porta il camminatore al di fuori dell'intervallo da 1 a 40, dovrebbe essere semplicemente ignorato e la posizione del camminatore rimane la stessa gestita correttamente.

Input dalle opzioni della riga di comando. Per esempio:

$ ./randwalk.sh 5 0.5
                    .
                     .
                    .
                  .
                 .
$ 

Ruby, 84

def w(s,n)q=19;n.times{puts ' '*q+'.';sleep s;q+=rand(5)-2;q=[[q,0].max,39].min};end

Python 2.7, 198 162 143 133

import time,random as r;p=20;s=0;d=input();w=input()
while s<d:
 print' '*p+'.';s+=1;p=max(1,min(p+r.randint(-2,2),40));time.sleep(w)

Quando si chiama lo script con python script.py, il primo input è la quantità di passaggi, il secondo input il tempo tra i passaggi (accetta float o int). Qualche suggerimento per migliorare?

Le modifiche

• risparmiato 36 byte perché ora utilizza print ' '*p+'.', grazie a @corsiKlause Ho Ho Ho
• giù altri 19 byte rimuovendo i rientri di tabulazione, sostituendoli con uno spazio o ;dove possibile
• 10 byte in meno grazie all'idea di @Bruce_Forte con p=max(1,min(p+r.randint(-2,2),40))(non posso commentare anche la tua risposta, ma grazie; non voglio copiarla completamente)

Elaborazione, 150 147

void w(int n,int s){int x=20,i,y,c=0;for(;c<n;c++){x+=y=int(random(5)-2);if(x>40||x<0)x-=y;for(i=1;i<x;i++)print(" ");println(".");delay(s*1000);}}

Uso:

void setup() {
    w(10,1);
}

Nota: 1000non può essere modificato 1e3per motivi di tipo.

Lua, 140 byte

Nota: questo programma richiede il pacchetto LuaSocket.

require"socket"p=19 for i=1,arg[2]+0 do print((" "):rep(p)..".")p=p+math.random(-2,2)p=p<0 and 0 or p>39 and 39 or p socket.sleep(arg[1])end

Perl 6 , 92 byte

my (\n,\s)=@*ARGS;$/=19;for (-2..2).roll(n) {put ' 'x($/+=(40>$/+$_>=0??$_!!0)),'.';sleep s} # 92

my (\n,\s)=@*ARGS;
$/=19;
for (-2..2).roll(n) {
  put ' 'x($/+=(40>$/+$_>=0??$_!!0)),'.';
  sleep s
}

Uso:

$ perl6 -e 'my (\n,\s)=@*ARGS;$/=19;for (-2..2).roll(n) {put " "x($/+=(40>$/+$_>=0??$_!!0)),".",;sleep s}' 10 0.001
                  .
                .
               .
              .
               .
                .
               .
                .
                  .
                 .

JavaScript (ES6), 125 byte

(s,n)=>(t=setTimeout)(c=`console.log(" ".repeat(p)+".");p+=m=Math.random()*5|0;p-=p>41|p<2?m:2;--i&&t(c,d)`,d=s*1e3,p=19,i=n)

Spiegazione

(s,n)=>
  (t=setTimeout)(                     // set inital timeout
    c=`                               // c = code for timeout to execute
      console.log(" ".repeat(p)+"."); // print the current line
      p+=m=Math.random()*5|0;         // move walker 0 - 4 positions to the right
      p-=p>41|p<2?                    // if walker was moved out of bounds (2 - 41 instead
                                      //     of 0 - 39 because the random move of 0 - 4 to
                                      //     the right has not had the 2 subtracted yet)
        m:                            // undo the move
        2;                            // else subtract 2 to make the move -2 to 2
      --i&&t(c,d)                     // while we have steps remaining schedule next one
    `,
    d=s*1e3,                          // d = milliseconds to wait between steps
    p=19,                             // p = position of walker (0 indexed)
    i=n                               // i = steps remaining (needed to make n global)
  )

Test

console.log = s => result.textContent += s + "\n";
var solution = (s,n)=>(t=setTimeout)(c=`console.log(" ".repeat(p)+".");p+=m=Math.random()*5|0;p-=p>41|p<2?m:2;--i&&t(c,d)`,d=s*1e3,p=19,i=n)

<input type="number" id="seconds" value="0.1" /><br />
<input type="number" id="steps" value="30" /><br />
<button onclick="solution(+seconds.value,+steps.value)">Go</button>
<pre id="result"></pre>

k4, 61 caratteri

f:{y{-1((y:1|40&y+-2+*1?5)#" "),".";."\\sleep ",$x;y}[x]\20;}

esempio di esecuzione:

  f[.1]30
                      .
                    .
                    .
                   .
                   .
                  .
                  .
                   .
                   .
                     .
                    .
                  .
                  .
                    .
                   .
                   .
                 .
                .
               .
               .
              .
            .
          .
         .
         .
          .
            .
              .
              .
                .

Mathematica, 122 117 byte

$RecursionLimit=∞;If[#2>0,Print[Indent[a=Min[#3+RandomInteger@{-2,2},39]~Max~0],"."];Pause@#;#0[#,#2-1,a]]&[##,19]&

Funzione anonima ricorsiva, accetta input nell'ordine specificato. Probabilmente potrebbe essere ulteriormente giocato a golf.

Python 3, 154 byte

import time
from random import*
w=int(input())
z=int(input())
g=19
c=6
s=" "
while c:
    c-=1
    s+=s
while z:
    z-=1
    if -1<g<40:
        print(s[:g]+'.')
    time.sleep(w)
    g+=randint(-2,2)

Generare una stringa di spazi maggiore della lunghezza massima richiesta, quindi stampare quella stringa SOLO fino al carattere nell'indice 'g', quindi stampare un '.'. Termina incrementando g di un valore casuale nell'intervallo [-2: 2] e ripeti.

Se qualcuno potesse aiutarmi a giocare a golf in quell'orribile blocco di input, lo apprezzerei.

C funtion, 114

s=20,i,t;w(int n,float f){for(;i++<n;t=s,s+=rand()%5-2,s=s<0||s>39?t:s,usleep((int)(f*1e6)))printf("%*c.\n",s,0);}

Praticamente una traduzione diretta di mia risposta bash .

Programma completo di test:

s=20,i,t;w(int n,float f){for(;i++<n;t=s,s+=rand()%5-2,s=s<0||s>39?t:s,usleep((int)(f*1e6)))printf("%*c.\n",s,0);}

int main (int argc, char **argv) {
  w(10, 0.2);
  return 0;
}