绘制一个程序或函数，该程序或函数将向STDOUT n时间（每个步）写入一个字符串，该字符串.在助行器的位置包含一个点。该程序还需要每秒钟写入一行s（或s在每行之后等待几秒钟）。

随机游走是路径的数学形式化，该路径由一系列随机步骤（wiki）组成，因此每个新步骤将是最后一个步骤加上一个新值，因此任何t步骤值都只是所有随机值的总和ir之前加上初始值。

该程序应具有2个输入，并且将在输出上仅使用空格" "和点"."。助行器的起始值20应使输出应为19个空格后的点。

                  . #19 spaces then a dot

每个新步骤的价值将是步行者的最后价值加上其中一个价值[-2-1,0,1,2]（每个价值20％的机会）。在打印新位置后，程序应等待s几秒钟，然后转到下一步。如果踏步使助步器偏离该范围1 to 40，则应忽略该范围，并且助步器位置保持不变。空格数始终是0到39之间的数字。

例

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

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

注意事项

• 您可以采用任何合理的格式输入

• 最短的代码胜出

• 没关系，如果您的程序只接受秒作为整数

珀斯39

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

注意到s作为输入的第一行和n作为第二参数。在命令行上有效，但不能与在线解释程序一起使用。我的第一个Pyth程序！打高尔夫球的技巧受到赞赏。

Matlab，112岁

核心思想是生成可能的下一个位置列表，然后统一绘制其中一个位置。如果我们位于例如位置$ l = 1 $，则可能的步长将是[-1,0,1,2,3]当然，如果我们选择-1该位置将是无效的，那么我们将不得不停留在相同的位置。因此，我们将无效位置替换为当前位置，[1,0,1,2,3]然后从此更新列表中随机选择一个元素。

OP要求我们绘制程序，所以我们开始：

转录：

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]

要求秒为整数。

用运行perl <filename> <second delay> <number of steps>。

这里可能会有更多的高尔夫潜力，尽管说实话，我很惊讶它达到了这么远。（来吧，只有6个字节才能击败bash答案...）

变化

• 通过删除不需要的括号并拼写ARGV，节省了8个字节（实际上这样更短）
• 通过去除保存12多个字节$s和$n与只使用简单的$ARGV[0]和$ARGV[1]
• 节省另外10个字节，当我意识到我可以使用$"，不需要专门定义$u的$undef。
• 通过重新排列三进制以及如何$x使用以及使用map代替节省了5个字节for。
• 通过不再接受秒作为小数位，节省了11个字节（挑战规范说还可以）。
• 使用say代替节省了5个字节print。

Python 2，124 119字节

@janrn和@Steve Eckert：我没有足够的声誉来评论您的答案，但实际上这是您的版本缩短了。任务是绘制程序或函数，因此通过使用f(s,x)您可以节省很多位，并且max(0,min(x,39))可以避免使用多余的if子句。归结为：

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

巴什，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
}

编辑：如果该步骤将步行者移出范围1到40，则应该将其忽略，并且步行者的位置将保持正确处理。

从命令行选项输入。例如：

$ ./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)

使用调用脚本时python script.py，第一个输入是步骤数，第二个输入是步骤之间的时间（接受float或int）。有什么改进建议吗？

编辑

• 由于现在使用print ' '*p+'.'，节省了36个字节，这要感谢@corsiKlause Ho Ho Ho
• 通过删除制表符缩进来再下移19个字节，用一个空格或;在可能的地方替换它们
• 多亏@Bruce_Forte的想法，p=max(1,min(p+r.randint(-2,2),40))所以少了10个字节（我也无法评论您的答案，但谢谢；不想完全复制它）

处理，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);}}

用法：

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

注意： 10001e3由于类型原因，无法将其更改为。

Lua，140字节

注意：此程序需要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个字节

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
}

用法：

$ 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个字节

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

说明

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

测试

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个字符

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

样品运行：

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

Mathematica，122 117字节

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

递归匿名函数，以指定顺序接受输入。可能会打得更远。

Python 3，154个字节

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'处的char，然后打印'。'。通过以[-2：2]范围内的随机值递增g来完成，然后重复。

如果有人可以帮助我在那个可怕的输入区打高尔夫球，我将不胜感激。

C函数，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);}

我bash答案的直接翻译。

完整的测试程序：

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