Dessinez un programme ou une fonction qui écrira en STDOUT ntemps (chacun pour une étape) une chaîne qui contient un point .à l'emplacement du déambulateur. Le programme doit également écrire une ligne toutes les ssecondes (ou attendre squelques secondes après chaque ligne).

Une marche aléatoire est une formalisation mathématique d'un chemin qui consiste en une succession d'étapes aléatoires ( wiki ), de sorte que chaque nouvelle étape sera la dernière étape plus une nouvelle valeur, donc toute tvaleur d'étape n'est que la somme de toutes les valeurs aléatoires avant ir plus la valeur initiale.

Le programme devrait prendre 2 entrées et n'utilisera que des espaces " "et des points "."sur la sortie. La valeur de départ du déambulateur sera 20telle que la sortie devrait être un point après 19 espaces.

                  . #19 spaces then a dot

À chaque nouvelle étape, la valeur sera la dernière valeur du déambulateur plus une de ces valeurs[-2-1,0,1,2] (20% de chance chacune). Une fois la nouvelle position imprimée, le programme doit attendre squelques secondes et passer à l'étape suivante. Si le pas met le déambulateur hors de portée, 1 to 40il doit être ignoré et la position du déambulateur reste la même. Le nombre d'espaces sera toujours un nombre compris entre 0 et 39.

Exemple

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

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

Considérations

• Vous pouvez prendre l'entrée dans n'importe quel format raisonnable

• Le code le plus court gagne

• Ce n'est pas grave si votre programme n'accepte que les secondes sous forme d'entiers

Pyth, 39

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

Prend scomme première ligne d'entrée et ncomme seconde. Fonctionne sur la ligne de commande mais pas avec l'interpréteur en ligne. Mon premier programme Pyth jamais! Les conseils de golf sont appréciés.

Matlab, 112

L'idée de base consiste à générer une liste des positions suivantes possibles, puis à dessiner uniformément l'une d'entre elles. Si nous sommes par exemple à la position $ l = 1 $, les étapes possibles seraient [-1,0,1,2,3]bien sûr si nous choisissions -1cela serait invalide et nous devrions rester à la même position. C'est pourquoi nous remplaçons les positions invalides par la position actuelle [1,0,1,2,3], puis choisissons au hasard un élément de cette liste mise à jour.

Le PO nous a demandé de dessiner le programme, alors c'est parti:

La transcription:

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 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]

Nécessite que les secondes soient un entier.

Courez avec perl <filename> <second delay> <number of steps>.

Il y a peut-être plus de potentiel de golf ici, mais honnêtement, je suis surpris que cela soit arrivé jusqu'ici. (Allez, seulement 6 octets de plus pour battre la réponse bash ...)

Changements

• 8 octets enregistrés en supprimant les parenthèses inutiles et en précisant ARGV (c'est en fait plus court de cette façon)
• Enregistré 12 octets de plus en supprimant $set $net en utilisant simplement le plain $ARGV[0]et$ARGV[1]
• J'ai enregistré 10 autres octets lorsque j'ai réalisé que je pouvais utiliser $"et que je n'avais pas besoin de définir spécifiquement $ucomme $undef.
• Sauvegardé 5 octets supplémentaires en réorganisant le ternaire et comment il $xest utilisé et en utilisant à la mapplace de for.
• Enregistrement de 11 octets en n'acceptant plus les secondes comme décimales (la spécification de défi dit que c'est OK.)
• Enregistré encore 5 octets en utilisant sayau lieu de print.

Python 2, 124 119 octets

@janrn et @Steve Eckert: Je n'ai pas assez de réputation pour commenter votre réponse mais voici essentiellement votre version raccourcie. La tâche consiste à dessiner un programme ou une fonction , donc en utilisant f(s,x)vous pouvez enregistrer pas mal de bits, ainsi vous pouvez utiliser max(0,min(x,39))pour éviter une ifclause supplémentaire . Je l'ai:

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
}

Edit: Si l'étape prend le déambulateur hors de la plage 1 à 40, il doit être simplement ignoré et la position du déambulateur reste la même gérée correctement.

Entrée à partir des options de ligne de commande. Par exemple:

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

Rubis, 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 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)

Lors de l'appel du script avec python script.py, la première entrée est la quantité d'étapes, la deuxième entrée le temps entre les étapes (accepte float ou int). Des suggestions d'amélioration?

Modifications

• économisé 36 octets grâce à l'utilisation actuelle print ' '*p+'.', grâce à @corsiKlause Ho Ho Ho
• vers le bas de 19 octets supplémentaires en supprimant les retraits de tabulation, les a remplacés par un espace ou ;si possible
• 10 octets de moins grâce à l'idée @Bruce_Forte avec p=max(1,min(p+r.randint(-2,2),40))(je ne peux pas commenter votre réponse également, mais merci; je ne veux pas la copier complètement)

Traitement, 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);}}

Usage:

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

Remarque: 1000ne peut pas être remplacé par 1e3pour des raisons de type.

Lua, 140 octets

Remarque: ce programme nécessite le package 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 octets

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
}

Usage:

$ 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 octets

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

Explication

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

Tester

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 caractères

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

échantillon:

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

Mathematica, 122 117 octets

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

Fonction anonyme récursive, prend les entrées dans l'ordre spécifié. Pourrait probablement être joué au golf plus loin.

Python 3, 154 octets

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)

Générez une chaîne d'espaces supérieure à la longueur maximale requise, puis imprimez cette chaîne UNIQUEMENT jusqu'au caractère à l'index 'g', puis imprimez un '.'. Terminez en incrémentant g d'une valeur aléatoire dans la plage [-2: 2] et répétez.

Si quelqu'un pouvait m'aider à jouer dans cet horrible bloc de saisie, j'apprécierais.

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

Une traduction directe de ma réponse bash .

Programme de test complet:

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