I'm working on modernizing Rosetta Code's infrastructure. Starting with communications. Please accept this time-limited open invite to RC's Slack.. --Michael Mol (talk) 20:59, 30 May 2020 (UTC)

# Long stairs

Long stairs is a draft programming task. It is not yet considered ready to be promoted as a complete task, for reasons that should be found in its talk page.

An evil wizard has trapped you in the stairwell of his castle. Your only hope of escape is to run up all 100 steps to reach the top, and you can run one step per second. Unfortunately the wizard uses magic to lengthen the staircase by five steps per second. The new steps are inserted randomly between existing steps, so if you're lucky some of them might be beneath you and not ahead of you.

Can you escape, or are you doomed to run up an ever-lengthening staircase forever?

Write a program to simulate your escape attempt. How are you doing after ten minutes? For every second between 600 and 609 seconds inclusive print the number of steps behind you and the number still ahead of you.

If you escaped, run 10,000 tests and print the average time taken and the average final length of the staircase.

## 11l

Translation of: C
`V secs_tot = 0V steps_tot = 0print(‘Seconds    steps behind    steps ahead’) L(trial) 1..10000   V sbeh = 0   V slen = 100   V secs = 0   L sbeh < slen      sbeh++      L 5         I random:(slen) < sbeh            sbeh++         slen++       secs++      I trial == 1 & secs C 600..609         print(‘#.        #.            #.’.format(secs, sbeh, slen - sbeh))    secs_tot += secs   steps_tot += slen print(‘Average secs taken: #.6’.format(secs_tot / 10000.0))print(‘Average final length of staircase: #.6’.format(steps_tot / 10000.0))`
Output:
```Seconds    steps behind    steps ahead
600        1906            1194
601        1910            1195
602        1913            1197
603        1918            1197
604        1923            1197
605        1929            1196
606        1934            1196
607        1936            1199
608        1940            1200
609        1943            1202
Average secs taken: 2920.077500
Average final length of staircase: 14700.387500
```

## C

` #include <stdio.h>#include <stdlib.h>#include <time.h> int main(void) {    int trial, secs_tot=0, steps_tot=0;     //keep track of time and steps over all the trials    int sbeh, slen, wiz, secs;              //all the variables related to an individual trial    time_t t;    srand((unsigned) time(&t));             //random number seed    printf( "Seconds    steps behind    steps ahead\n" );    for( trial=1;trial<=10000;trial++ ) {   //10000 attempts for the runner        sbeh = 0; slen = 100; secs = 0;     // initialise this trial        while(sbeh<slen) {                  //as long as the runner is still on the stairs            sbeh+=1;                        //runner climbs a step            for(wiz=1;wiz<=5;wiz++) {       //evil wizard conjures five new steps                if(rand()%slen < sbeh)                    sbeh+=1;                //maybe a new step is behind us                slen+=1;                    //either way, the staircase is longer            }            secs+=1;                        //one second has passed            if(trial==1&&599<secs&&secs<610)                printf("%d        %d            %d\n", secs, sbeh, slen-sbeh );         }        secs_tot+=secs;        steps_tot+=slen;    }    printf( "Average secs taken: %f\n", secs_tot/10000.0 );    printf( "Average final length of staircase: %f\n", steps_tot/10000.0 );     return 0;}`
Output:
```
600        2147            953
601        2151            954
602        2156            954
603        2160            955
604        2166            954
605        2169            956
606        2174            956
607        2180            955
608        2184            956
609        2188            957
Average secs taken: 2921.493200
Average final length of staircase: 14707.466000

```

## Factor

`USING: combinators.random io kernel math math.order prettyprint ; : position (     -- n   ) 0 ;: stairs   (     -- n   ) 100 ;: new      (     -- m n ) position stairs ;: incd     ( m n -- o p ) swap 1 + swap ;: seconds  ( m   -- n   ) 100 - 5 / ;: window?  ( n   -- ?   ) seconds 600 609 between? ;: zap      ( m n -- o p ) 2dup / [ incd ] whenp 1 + ;: barrage  ( m n -- o p ) 5 [ zap ] times ;: .n       ( n   --     ) pprint 7 [ bl ] times ;: .stats   ( m n --     ) dup seconds .n over .n swap - .n nl ;: .header  (     --     ) "Seconds  behind     ahead" print ;: ?.status ( m n -- o p ) dup window? [ 2dup .stats ] when ; : tick     ( m n -- o p ) incd barrage ;: demo     ( m n -- o p ) tick ?.status ;: sim-with ( q   -- n   ) new rot [ 2dup < ] swap while drop ; inline: first    (     -- n   ) [ demo ] sim-with ;: sim      (     -- n   ) [ tick ] sim-with ;: sims     (     -- n   ) 0 first + 9999 [ sim + ] times ;: steps    ( m   -- n   ) "Avg. steps: " write 10000 / dup . ;: time     ( n   --     ) "Avg. seconds: " write seconds . ;: main     (     --     ) .header sims nl steps time ; main`
Output:
```Seconds  behind     ahead
600       2067       1033
601       2073       1032
602       2078       1032
603       2082       1033
604       2087       1033
605       2091       1034
606       2096       1034
607       2099       1036
608       2103       1037
609       2108       1037

Avg. steps: 14731+23/200
Avg. seconds: 2926+223/1000
```

And for fun, a version without stack effects.

`USING: combinators.random effects.parser io kernel mathmath.order parser prettyprint stack-checker words ; << SYNTAX: .: [ scan-new-word parse-definition dup infer ]    with-definition define-declared ; >> .: position  0 ;.: stairs    100 ;.: new       position stairs ;.: incd      swap 1 + swap ;.: seconds   100 - 5 / ;.: window?   seconds 600 609 between? ;.: zap       2dup / [ incd ] whenp 1 + ;.: barrage   5 [ zap ] times ;.: .n        pprint 7 [ bl ] times ;.: .stats    dup seconds .n over .n swap - .n nl ;.: .header   "Seconds  behind     ahead" print ;.: ?.status  dup window? [ 2dup .stats ] when ; .: tick      incd barrage ;.: demo      tick ?.status ;.: first     new [ 2dup < ] [ demo ] while drop ;.: sim       new [ 2dup < ] [ tick ] while drop ;.: sims      0 first + 9999 [ sim + ] times ;.: steps     "Avg. steps: " write 10000 / dup . ;.: time      "Avg. seconds: " write seconds . ;.: main      .header sims nl steps time ; main`

## Fermat

` time_tot:=0;    {we'll keep track of the total time and steps across all the trials}steps_tot:=0;   !!('Seconds    ','Steps behind    ','Steps ahead');for trial = 1 to 10 do     s_behind:=0;    {initialise staircase and runner for this trial}    stair_len:=100;    time:=0;    while s_behind < stair_len do        s_behind:=s_behind + 1;        for wiz = 1 to 5 do            stair_len:=stair_len + 1;  {evil wizard creates a step}  {(mwaahahaha)}            if (Rand|stair_len) < s_behind then                 s_behind:=s_behind + 1;            fi        od;        time:=time+1;   {another second has passed}        if trial = 1 and 599<time and time<610 then            !!(time, '       ', s_behind, '           ',stair_len-s_behind)        fi;    od;    time_tot:=time_tot+time;    steps_tot:=steps_tot+stair_len;od; !!(time_tot/10000);!!(steps_tot/10000);`
Output:
```

600        2125            975
601        2129            976
602        2132            978
603        2136            979
604        2142            978
605        2146            979
606        2151            979
607        2156            979
608        2162            978
609        2166            979
3697083 / 1250
3722083 / 250

```

## FreeBASIC

` randomize timerdim as uinteger steps_behind = 0, stairs_length = 100, seconds, jdim as uinteger seconds_tot, steps_totprint "Seconds", "steps behind", "steps ahead"for trial as uinteger = 1 to 10000        'We'll have the runner try this 10000 times    steps_behind = 0                      'runner starts at the bottom    seconds = 0                           'reset time taken    stairs_length = 100                   'Staircase has 100 steps    while steps_behind < stairs_length    'if the runner hasn't reached the top        steps_behind += 1                 'go up one step        for j = 1 to 5                    'The evil wizard conjures another five steps            if int(rnd*stairs_length) < steps_behind then steps_behind += 1                                          'there's a chance that a new step will be behind you            stairs_length += 1            'but either way the staircase is one step longer        next j        seconds += 1                      'that all took one second        if trial = 1  and seconds >599 and seconds < 610  then print seconds, steps_behind, stairs_length - steps_behind                                          'for the first attempt, see how the runner is doing after ten minutes    wend    seconds_tot += seconds                'if the runner escaped, track the time taken and the length of the stairs    steps_tot += stairs_lengthnext trial print "Average time taken: ";seconds_tot/10000; " seconds."print "Average final staircase length: ";steps_tot/10000; " steps."'if you noticed that last number is about 100*exp(5), that's no coincidence`
Output:
```
600           2032          1068
601           2038          1067
602           2042          1068
603           2045          1070
604           2048          1072
605           2053          1072
606           2055          1075
607           2060          1075
608           2064          1076
609           2068          1077
Average time taken:  2921.9457 seconds.
Average final staircase length:  14709.7285 steps.

```

## GW-BASIC

` 10 RANDOMIZE TIMER20 TIMET = 0 : STEPST = 030 FOR TRIAL = 1 TO 1000040 TIME = 050 SBEH = 060 SLEN = 10070 SBEH = SBEH + 180 IF SBEH >= SLEN THEN GOTO 16090 FOR WIZ = 1 TO 5100 IF INT(RND*SLEN)<SBEH THEN SBEH = SBEH + 1110 SLEN = SLEN + 1120 NEXT WIZ130 TIME = TIME + 1140 IF TRIAL = 1 AND 599<TIME AND TIME <610 THEN PRINT TIME, SBEH, SLEN-SBEH150 GOTO 70160 TIMET = TIMET+TIME+1170 STEPST = STEPST + SLEN180 NEXT TRIAL190 PRINT TIMET/10000200 PRINT STEPST/10000`

## Go

Translation of: Wren
`package main import (    "fmt"    "math/rand"    "time") func main() {    rand.Seed(time.Now().UnixNano())    totalSecs := 0    totalSteps := 0    fmt.Println("Seconds    steps behind    steps ahead")    fmt.Println("-------    ------------    -----------")    for trial := 1; trial < 10000; trial++ {        sbeh := 0        slen := 100        secs := 0        for sbeh < slen {            sbeh++            for wiz := 1; wiz < 6; wiz++ {                if rand.Intn(slen) < sbeh {                    sbeh++                }                slen++            }            secs++            if trial == 1 && secs > 599 && secs < 610 {                fmt.Printf("%d        %d            %d\n", secs, sbeh, slen-sbeh)            }        }        totalSecs += secs        totalSteps += slen    }    fmt.Println("\nAverage secs taken:", float64(totalSecs)/10000)    fmt.Println("Average final length of staircase:", float64(totalSteps)/10000)}`
Output:

Sample run:

```Seconds    steps behind    steps ahead
-------    ------------    -----------
600        2138            962
601        2143            962
602        2148            962
603        2153            962
604        2159            961
605        2163            962
606        2167            963
607        2172            963
608        2177            963
609        2183            962

Average secs taken: 2917.9058
Average final length of staircase: 14689.519
```

## jq

Works with: jq

Works with gojq, the Go implementation of jq

Neither the C nor the Go-based implmentations of jq currently have a built-in PRNG, so for the present task /dev/urandom is used as a source of entropy by invoking jq as follows:

```cat /dev/urandom | tr -cd '0-9' | fold -w 1 | jq -nrf long-stairs.jq
```

where long-stairs.jq contains the jq program shown below. For simplicity and since the intermediate output has the character of a probe, the program uses `debug` statements to show the intermediate results.

`# 0 <= output < \$ndef rand(\$n):   def ntimes(f): range(0; .) | f;   # input: an array of length (\$n|tostring|length)  def r:    . as \$in    | (join("") | tonumber) as \$m    | if \$m < \$n then \$m      else \$in[1:] + [input] | r      end;  [\$n | tostring | length | ntimes(input)] | r; # \$n specifies the number of iterationsdef task(\$n):  (reduce range(1; \$n + 1) as \$trial (null;    .sbeh = 0    | .slen = 100    | .secs = 0    | until (.sbeh >= .slen;        .sbeh += 1        | reduce range(1;6) as \$wiz (.;            if (rand( .slen) < .sbeh) then .sbeh += 1 else . end            | .slen += 1 )        | .secs += 1        | if (\$trial == 1 and .secs > 599 and .secs < 610)          then  ([.secs, .sbeh, .slen - .sbeh] | debug) as \$debug | .          else .          end )    | .totalSecs  += .secs    | .totalSteps += .slen ) ) ; "Seconds    steps behind    steps ahead","-------    ------------    -----------",(1E4 as \$n| task(\$n)| "\nAverage secs taken over \(\$n) trials: \(.totalSecs/\$n)",  "Average final length of staircase: \(.totalSteps/\$n)")`
Output:
```Seconds    steps behind    steps ahead
-------    ------------    -----------
["DEBUG:",[600,1916,1184]]
["DEBUG:",[601,1919,1186]]
["DEBUG:",[602,1920,1190]]
["DEBUG:",[603,1924,1191]]
["DEBUG:",[604,1926,1194]]
["DEBUG:",[605,1931,1194]]
["DEBUG:",[606,1934,1196]]
["DEBUG:",[607,1938,1197]]
["DEBUG:",[608,1942,1198]]
["DEBUG:",[609,1945,1200]]

Average secs taken over 10000 trials: 3211.962
Average final length of staircase: 16159.81
```

## Julia

`""" https://rosettacode.org/wiki/Long_stairs """ using Statistics struct LongStairs    startstep::Int    startlength::Int    climbersteps::Int    addsteps::Intend Base.length(LongStairs) = typemax(Int)Base.eltype(ls::LongStairs) = Vector{Int} function Base.iterate(s::LongStairs, param = (s.startstep, s.startlength))     pos, len = param     pos += s.climbersteps      pos += sum(pos .> rand(1:len, s.addsteps))     len += s.addsteps     return [pos, len], (pos, len)end ls = LongStairs(1, 100, 1, 5) println("Seconds  Behind  Ahead\n----------------------")for (secs, (pos, len)) in enumerate(collect(Iterators.take(ls, 609))[600:609])    println(secs + 599, "      ", pos, "    ", len - pos)end println("Ten thousand trials to top:")times, heights = Int[], Int[]for trial in 1:10_000    trialstairs = LongStairs(1, 100, 1, 5)    for (sec, (step, height)) in Iterators.enumerate(trialstairs)        if step >= height            push!(times, sec)            push!(heights, height)            break        end    endend@show mean(times), mean(heights) `
Output:
```Seconds  Behind  Ahead
----------------------
601      1938    1167
602      1944    1166
603      1948    1167
604      1952    1168
605      1956    1169
606      1959    1171
607      1963    1172
608      1967    1173
609      1971    1174
Ten thousand trials to top:
(mean(times), mean(heights)) = (2927.0853, 14735.4265)
```

## Pascal

### Free Pascal

Trying to calculate results of multiple random rounds.Now a partial step forward 1/CntOfSpellStairs for every spell stair.
Now results are much closer.

`program WizardStaircase;const  StartStairLength = 100;  StairsPerSpell = 5;  rounds = 10000; procedure OutActual(trials,behind,infront:longword);begin  writeln(trials:5,infront+behind:12,behind:10,inFront:9);end; function OneRun(StairsPerSpell:Cardinal;WithOutput:boolean):longword;var  inFront,behind,total,i,trials: Cardinal;begin  trials := 0;  total := StartStairLength;  inFront := total;  behind := 0;  repeat    inc(trials);    inc(behind);    dec(infront);    //spell    i := StairsPerSpell;    repeat      if random(total) < behind then        inc(behind)      else        inc(infront);      inc(total);      dec(i);    until i=0;    if WithOutput then    begin      if (trials <= 609)AND(trials>=600) then        OutActual(trials,behind,infront);    end;  until infront = 0;  OneRun := total;end; procedure CheckDouble(StairsPerSpell:Cardinal);var  behind,infront,relpos,total,One,relSpell : double;  i : LongInt;begin  write(StairsPerSpell:3);  One := 1.0;  behind := 0.0;  inFront  := StartStairLength;  total    := StartStairLength;  relSpell := One/StairsPerSpell;  repeat    i := StairsPerSpell;    //doing a partial move per one stair per spell    repeat      relpos  := (behind+relSpell)/total;      behind  := behind +     relpos +relSpell;      inFront := inFront+(One-relpos)-relSpell;      total   := total+One;      dec(i);    until i= 0;  until infront < One;  writeln((total-StartStairLength)/StairsPerSpell:10:0,total:14:0);end; var  i,  mySpell,  attempt,  minStairs,  maxStairs,  total : longword;begin  randomize;  writeln('Seconds  steps total  behind    ahead');  total := OneRun(StairsPerSpell,true);   writeln('      average stairs needed steps minimum   maximum');  for mySpell := 1 to 7 do  begin    write(mySpell:3,'  ');    total := 0;    minStairs := High(minStairs);    maxStairs := low(maxStairs);    For i := rounds-1 downto 0 do    begin      attempt:= OneRun(mySpell,false);      if minStairs>attempt then        minstairs := attempt;      if maxStairs<attempt then        maxstairs := attempt;      inc(total,attempt);    end;    writeln((total-StartStairLength)/rounds/mySpell:12:3,total/rounds:14:3,minStairs:9,maxStairs:10);  end;  writeln;   writeln(' calculated ');  For i := 1 to 10 do    CheckDouble(i);end.`
@ TIO.RUN:
```Seconds  steps total  behind    ahead
600        3100      2260      840
601        3105      2264      841
602        3110      2269      841
603        3115      2275      840
604        3120      2281      839
605        3125      2285      840
606        3130      2291      839
607        3135      2295      840
608        3140      2300      840
609        3145      2302      843
average stairs needed steps minimum   maximum
1       271.090       271.100      239       313
2       367.570       735.150      540       954
3       663.998      1992.003     1234      2911
4      1353.416      5413.674     2748      8980
5      2933.418     14667.099     6715     27210
6      6648.557     39891.354    18394     80050
7     15550.874    108856.130    42380    218892

calculated
1       170           270
2       317           734
3       633          1999
4      1333          5432
5      2933         14765
6      6673         40138
7     15573        109111
8     37063        296604
9     89573        806257
10    219154       2191640

Real time: 55.269 s```

## Phix

```with javascript_semantics -- (nb expect blank screen for ~30s)

integer total_seconds = 0,
total_steps = 0
printf(1,"----  ------  -----\n")
for trial=1 to 10_000 do
integer stairs_length = 100,
steps_behind = 0,
seconds = 0
while steps_behind < stairs_length do
steps_behind += 1
for wizard=1 to 5 do
steps_behind += (rnd()*stairs_length < steps_behind)
stairs_length += 1
end for
seconds += 1
if trial=1 and seconds>=600 and seconds<=609 then
printf(1,"%4d %7d %6d\n", {seconds, steps_behind, stairs_length-steps_behind})
end if
end while
total_seconds += seconds
total_steps += stairs_length
if trial=1 then printf(1,"\n") end if
end for
printf(1,"Average seconds: %f, average steps: %f\n",
{total_seconds/10000,total_steps/10000})
```
Output:
```time  behind  ahead
----  ------  -----
600    1978   1122
601    1980   1125
602    1986   1124
603    1990   1125
604    1995   1125
605    1999   1126
606    2002   1128
607    2004   1131
608    2008   1132
609    2012   1133

Average seconds: 2913.609300, average steps: 14668.046500
```

## Perl

`#!/usr/bin/perl use strict; # https://rosettacode.org/wiki/Long_stairsuse warnings; my \$sumseconds = my \$sumsizes = my \$runs = 0;for ( 1 .. 1e4 )  {  \$runs++;  my \$behind = 0;  my \$ahead =  100;  my \$seconds = 0;  while( \$ahead  > 0 )    {    rand() <= (\$ahead / (\$behind + \$ahead)) ? \$ahead++ : \$behind++ for 1 .. 5;    \$behind++; # one step up    \$ahead--;    \$seconds++;    \$_ == 1 and 600 <= \$seconds <= 609 and      print "step \$seconds: \$behind behind, \$ahead ahead\n";    }  \$sumsizes += \$behind;  \$sumseconds += \$seconds;  }printf "\naverage stair length %d average seconds %d\n",  \$sumsizes / \$runs, \$sumseconds / \$runs;`
Output:
```step 600: 2233 behind, 867 ahead
step 601: 2237 behind, 868 ahead
step 602: 2241 behind, 869 ahead
step 603: 2247 behind, 868 ahead
step 604: 2249 behind, 871 ahead
step 605: 2254 behind, 871 ahead
step 606: 2258 behind, 872 ahead
step 607: 2262 behind, 873 ahead
step 608: 2268 behind, 872 ahead
step 609: 2273 behind, 872 ahead

average stair length 15438 average seconds 3067
```

## Python

`""" https://rosettacode.org/wiki/Long_stairs """ from numpy import meanfrom random import sample def gen_long_stairs(start_step, start_length, climber_steps, add_steps):    secs, behind, total = 0, start_step, start_length    while True:        behind += climber_steps        behind += sum([behind > n for n in sample(range(total), add_steps)])        total += add_steps        secs += 1        yield (secs, behind, total)  ls = gen_long_stairs(1, 100, 1, 5) print("Seconds  Behind  Ahead\n----------------------")while True:    secs, pos, len = next(ls)    if 600 <= secs < 610:        print(secs, "     ", pos, "   ", len - pos)    elif secs == 610:        break print("\nTen thousand trials to top:")times, heights = [], []for trial in range(10_000):    trialstairs = gen_long_stairs(1, 100, 1, 5)    while True:        sec, step, height = next(trialstairs)        if step >= height:            times.append(sec)            heights.append(height)            break print("Mean time:", mean(times), "secs. Mean height:", mean(heights)) `
Output:
```Seconds  Behind  Ahead
----------------------
600       2122     978
601       2127     978
602       2130     980
603       2135     980
604       2139     981
605       2144     981
606       2149     981
607       2153     982
608       2157     983
609       2162     983

Ten thousand trials to top:
Mean time: 2780.502 secs. Mean height: 14002.51
```

## Raku

`my (\$trials, \$t-total, \$s-total) = 10000; say 'Seconds  steps behind  steps ahead'; race for ^\$trials {    my \$stairs   = 100;    my \$location = 0;    my \$seconds  = 0;     loop {        ++\$seconds;        ++\$location;        last if \$location > \$stairs;        for (1..\$stairs).roll(5) {            ++\$location if \$_ <= \$location;            ++\$stairs;        }        say "  \$seconds        \$location         {\$stairs-\$location}" if !\$_ && (599 < \$seconds < 610);    }     \$t-total += \$seconds;    \$s-total += \$stairs;} say "Average seconds: {\$t-total/\$trials},  Average steps: {\$s-total/\$trials}";`
Sample output:
```Seconds  steps behind  steps ahead
600        2143         957
601        2149         956
602        2153         957
603        2158         957
604        2164         956
605        2170         955
606        2175         955
607        2178         957
608        2183         957
609        2187         958
Average seconds: 2716.0197,  Average steps: 13677.143```

## Vlang

Translation of: Wren
Library: Vlang-rand
`import rand fn main() {    mut total_secs := 0    mut total_steps := 0    println("Seconds    steps behind    steps ahead")    println("-------    ------------    -----------")    for trial in 1..10000 {        mut sbeh := 0        mut slen := 100        mut secs := 0        for sbeh < slen {            sbeh++            for _ in 1..5 {                if rand.intn(slen) or {0} < sbeh {                    sbeh++                }                slen++            }            secs++            if trial == 1 && secs > 599 && secs < 610 {                println("\$secs        \$sbeh            \${slen-sbeh}")            }        }        total_secs += secs        total_steps += slen    }    println("\nAverage secs taken: \${total_secs/10000}")    println("Average final length of staircase: \${total_steps/10000}")}`
Output:

Sample run:

```Seconds    steps behind    steps ahead
-------    ------------    -----------
600        2112            988
601        2115            990
602        2121            989
603        2126            989
604        2130            990
605        2135            990
606        2141            989
607        2146            989
608        2150            990
609        2155            990

Average secs taken: 2914.465
Average final length of staircase: 14672.325
```

## Wren

Translation of: C
Library: Wren-fmt
`import "random" for Randomimport "./fmt" for Fmt var totalSecs = 0var totalSteps = 0var rand = Random.new()System.print("Seconds    steps behind    steps ahead")System.print("-------    ------------    -----------")for (trial in 1..10000) {    var sbeh = 0    var slen = 100    var secs = 0    while (sbeh < slen) {        sbeh = sbeh + 1        for (wiz in 1..5) {            if (rand.int(slen) < sbeh) sbeh = sbeh + 1            slen = slen + 1        }        secs = secs + 1        if (trial == 1 && secs > 599 && secs < 610) {            Fmt.print("\$d        \$d            \$d", secs, sbeh, slen - sbeh)        }    }    totalSecs  = totalSecs + secs    totalSteps = totalSteps + slen}Fmt.print("\nAverage secs taken: \$h", totalSecs/10000)Fmt.print("Average final length of staircase: \$h", totalSteps/10000)`
Output:

Sample run:

```Seconds    steps behind    steps ahead
-------    ------------    -----------
600        2112            988
601        2115            990
602        2121            989
603        2126            989
604        2130            990
605        2135            990
606        2141            989
607        2146            989
608        2150            990
609        2155            990

Average secs taken: 2914.465
Average final length of staircase: 14672.325
```