还记得那些蛮力破解密码的程序，它们显示了他们尝试的每种组合吗？更准确地说，在某个时刻，固定了n个第一个字符（已经成功猜出了它们），其余的每个可能的字符都在测试中。您可能已经看过电影或喜欢精美界面的人编写的某些软件。
抱歉，我们很抱歉，但是我们不会编写破解密码的程序，而只提供一个程序来复制漂亮的输出。

挑战

给定一个包含可打印的ascii字符但没有换行符的字符串（ascii代码32到126或与regex匹配^[ -~]{2,}$），请按照以下规则打印输出：

• 在时间t=n seconds，n打印的n第一个字符是输入字符串的第一个字符。
• 的后n固定字符，则应该字符串形成随机字符追加（从unicode的范围内选择均匀地伪随机   ，以~（码32至126）），以形成所述初始之一的长度的字符串。
• 您应该每秒至少输出20行（稍后再详细介绍）：每个行将具有相同的n首字符，但随机结尾不同。

目前尚不清楚您应该做什么，所以让我们来看一个例子：

例

我每秒钟只打印5条不同的行，而不是20条最小值，只是为了使其更具可读性。

考虑输入abcde。
在第一秒内，有效输出可能类似于（完全随机）：

dGuT4
S!jkN
"gQ>[
TU3! 
*fAjV

然后，t=1每个后续字符串a的第一个字符将是（输入的第一个字符）：

a);jD
aHv^p
aqw5*
a|.?:
a{gbK

现在，，t=2前两个字符为ab：

abTJ"
ab\ e
ab3T#
abYWS
ab"#<

现在，t=3前三个字符为abc：

abcvW
abc3G
abc(g
abc{@
abc@4

现在，t=4前四个字符为abcd：

abcdD
abcdv
abcdj
abcd$
abcd6

最后，t=5我们打印输入（仅一次）：

abcde

一些精度

• 您不应该对秒级的语言精度太费心（例如，如果您的算法正确但系统/语言缺乏精度，那就很好了）。
• 第一秒可以短于一秒（也就是说，如果您在一秒钟内启动程序，则第一秒可能只是直到当前秒结束为止的剩余时间）。或者换句话说，您不必等待新的一秒开始打印输出。
• 每秒至少20行：更自然的方法是每秒执行一次特殊行为的无限循环（或超时，或其他），因此每秒可能会产生几千行（这很好！ ）。但是，如果您有其他想法，只要您每秒打印至少20行，就可以随意使用它。
• 输入将始终超过2个字符长。
• 您可以考虑，如果有帮助，输入的长度不能超过30个字符。（但如果它适用于更长的时间，那是最好的）
• 输入格式应该是您语言中字符串的最自然的表示形式。
• 您可以打印尾随换行符。

代码示例

如果仍然不完全了解您必须执行的操作，则可以在linux终端中运行以下代码以查看：

perl -F -aplE 'map{$t=time;print$s,map{chr 32+rand 94}@F until$t-time;$s.=shift@F}@F' <<< "Cracking in progress\!"

获奖标准

这是代码高尔夫球，因此以字节为单位的最短代码获胜！

Pyth- 27 24字节

实际上看起来很酷：D

WJ-lQKs.d1+<QKsmOr;\~J;Q

在此处在线尝试（显然不是实时的，但是如果您用稳定的手向下滚动它）。

HTML / JavaScript中，170个 168 167字节

setInterval('o.textContent=i.value.replace(/./g,(c,i)=>new Date-d>++i*1e3?c:String.fromCharCode(Math.random()*95+32))',d=50)

<input id=i oninput=d=Date.now()><pre id=o>

编辑：由于@ETHproductions，节省了2个字节。@jrich节省了1个字节。

节点，145个 142字节

for(s=process.argv[2],d=new Date;s[a=(new Date-d)/1e3|0]+console.log(s.replace(/./g,(c,i)=>i<a?c:String.fromCharCode(32+Math.random()*95))););

这似乎有点长，而且可能还有打高尔夫球的空间。请注意，最后必须使用分号；没有它，程序将引发语法错误，因为该for语句没有正文。

输出方式每秒超过20行；一只小鸟告诉我，大约是一万二千。这是我计算机上的ConEmu终端仿真器中的样子（以30 fps记录）：

05AB1E，26个字节

我将其发布为与其他05AB1E答案不同的答案，因为方法不同

.põ¸ì¨vT·FyžQ.r¹gyg-£«}}¹»

.p                         Generate ordered prefix of input (e.g., ["a", "ab", "abc", "abcd", "abcde"] for "abcde")
  õ¸ì                      Prepend an empty string (e.g., result is ["", "a", "ab", ...])
     ¨                     Strip the last element (the same string as the input)
      v                    For each string in the array
       T·F                 For N in range(20)
          y                Push the current string
           žQ.r            Push all printable characters, shuffled
               ¹gyg-       Take the difference between the length of the input and the length of the current string -> x
                    £      Take the x first characters from the shuffled printable characters
                     «     Yield currentString + shuffledCharacters
                      }    End inner for
                       }   End outer for
                        ¹  Push input (last iteration)
                         » Join everything with newlines and implicitly display

在线尝试！

BASH，99 93 92 91 88字节

用tr+ head+urandom

while ((${#1}-n));do
echo "${1::n=SECONDS}`tr -dc \ -~</dev/ur*|head -c$[${#1}-n]`"
done

（致谢@manatwork）

05AB1E，30个字节

gFžcUNV[¹Y£žQ.r¹gY-£J,XžcÊ#}¹,

使用CP-1252编码。在线尝试！

请帮我打高尔夫球。

C，182个 176 128 126 125字节

打高尔夫球：

i;s;n;x;g(char*c){time(&s);while(c[++x]);do{n=time(0)-s;for(i=0;i<x;i++)putchar(i<n?c[i]:32+rand()%95);puts("");}while(n<x);}

取消高尔夫：

#include "stdio.h"
#include "stdlib.h"
#include "time.h"
int i,s,n,x;
void g(char* c) {
  time(&s); //Get the initial time
  while(c[++x]); // x = strlen(c) (happy about this one)
  do {
    n = time(0) - s; //seconds since beginning
    for(i = 0; i < x; i++)
      //after each second, print another char of the password
      putchar(i < n ? c[i] : 32 + rand() % 95);
    puts("");
  } while(n < x); //while we haven't printed the whole word
}

我听说有可能删除一些标准#include的，但是我无法在刚刚下载的MingW GCC编译器上使用它。同样，如果不#define b #include使用超出其价值的空间也无法解决。 我只是个白痴，没有他们，它很好用。

Java 7中，271个 265 207字节

void c(String s)throws Exception{for(int i=0,j,l=s.length();i<=l*20;i++){String r=s.substring(0,i/20);Thread.sleep(45);for(;j++<l;r+=(char)(32+Math.random()*95);System.out.println(r);if(s.equals(r))return;}}

@OliverGrégoire节省了-58字节。（不要忘记赞扬他更短的Java 8答案。）

取消高尔夫：

void c(String s) throws Exception{
  for(int i = 0, j, l = s.length(); i <= l*20; i++){
    String r = s.substring(0, i/20);
    Thread.sleep(45);
    for( ; j++ < l; r += (char)(32+Math.random()*95));
    System.out.println(r);
    if(s.equals(r)){
      return;
    }
  }
}

输入： abcde
输出：

WinDbg中，400个 391字节

.for(r$t1=@$t0;by(@$t1);r$t1=@$t1+1){};m@$t0 L@$t1-@$t0+1 @$t1+1;r$t4=2*@$t1+2-@$t0;r$t8=@$t4+f;r$t3=0;.for(r$t2=0;@$t2<@$t1-@$t0;da@$t0){.for(r$t7=@$t0+@$t2;by(@$t7);r$t7=@$t7+1;r$t8=@$t8+1){eb@$t7 by(@$t8)%5e+20};r$t9=0;.foreach(p {.echotime}){.if7==@$t9{ea@$t4"p";.if1>@$t3{r$t3=by(@$t4+7)}};r$t9=@$t9+1};j@$t3!=by(@$t4+7)'m@$t0+@$t4-@$t1+@$t2-1 L1 @$t0+@$t2;r$t2=@$t2+1;r$t3=by(@$t4+7)'}

通过简化一些数学运算来获得-9个字节

这绝对不是WinDbg打算做的事情。;）

通过在存储位置输入一个ascii字符串并将该地址设置为伪寄存器来进行输入$t0。例如：

r$t0 = 2000000
eza @$t0 "abcde"

我正在使用的prng是内存中的内容，即输入字符串后的一些字节。Chrome.exe似乎0x2000000用足够看起来随机的字节填充了内存空间，因此我使用了chrome.exe转储。不知道这是否统一，但对我来说看起来足够随机。

这个怎么运作：

.for(r$t1=@$t0; by(@$t1); r$t1=@$t1+1){};         * From $t0, increment $t1 until the byte
                                                  * at $t1 is 0 to find length of input
m@$t0 L@$t1-@$t0+1 @$t1+1;                        * Duplicate input (memory 
                                                  * becomes: "input\0input\0")

r$t4=2*@$t1+2-@$t0;                               * Set $4 to the byte after \0 of the 
                                                  * duplicated input
r$t8=@$t4+f;                                      * Set $t8 to $t4+15, this is the prng
r$t3=0;                                           * Init $t3=0, this will hold the time

.for(r$t2=0; @$t2<@$t1-@$t0; da@$t0){             * For $t2=0, loop until it's input length,
                                                  * printing the string at $t0 after each
                                                  * loop. $t0 is where the password crack
                                                  * progress is written.
    .for(r$t7=@$t0+@$t2; by(@$t7); r$t7=@$t7+1;   * Loop over each uncracked char
                                   r$t8=@$t8+1){  * also incrementing prng ($t8)
        eb@$t7 by(@$t8)%5e+20                     * Write a visible ascii char onto the
                                                  * uncracked char position based on the 
                                                  * current byte of prng%0x5e+0x20 (prng%126+32)
    };

    r$t9=0;                                       * Set $t9=0 for updating current time
    .foreach(p {.echotime}){                      * For each (string) word in a statement
                                                  * like "Debugger (not debuggee) time: Mon 
                                                  * Nov 21 18:23:08.433 2016 (UTC - 8:00)"
        .if7==@$t9{                               * If the 7th word, ie- the current time
            ea@$t4"p";                            * Write the time at $t4
            .if1>@$t3{                            * If $t3 has not been set yet
                r$t3=by(@$t4+7)                   * ...save the current second in $t3
            }
        };
        r$t9=@$t9+1                               * Increment $t9 until it's 7
    };

    j@$t3!=by(@$t4+7)'                            * If the current second has changed
        m@$t0+@$t4-@$t1+@$t2-1 L1 @$t0+@$t2;      * Copy the cracked char from dupe input
        r$t2=@$t2+1;                              * Increment $t2 (loop ends when this is input length)
        r$t3=by(@$t4+7)                           * Save the new current second
    '
}                                                 * Final crack is printed by for loop

注意：可以使用j而不是.if's 来获取某些字节，但这会导致它在我的计算机上运行太慢，因此每秒不会输出至少20行，因此不保存这些字节。

样本输出：http：//pastebin.com/H4H74sAx

R，138个字节

z=Sys.time;n=nchar(x<-scan(,""));s=z();t=0;while(t<=n){t=t+z()-s;cat(substr(x,1,f<-floor(t)),intToUtf8(sample(32:126,n-f,T)),"\n",sep="")}

从标准输入读取输入。

在我的机器上的“密码”中的每个附加字母之间计算了大约61行。

击，247个 245 212 207字节

R()(echo $SECONDS);w=`R`;until [ "$a" = "$1" ];do for i in `seq 1 $[${#1}-${#a}]`;{ a+=`printf "\x$(printf %x $[$RANDOM%127+32])"`;};echo -e "$a\r";a=${1:0:q};((`R`-w>0))&&{ w=`R`;((q++));}||:;done;echo "$a"

非常感谢Bash对空格如此敏感...

无论如何，输出是在单独的行上实时给出的。另存为.sh脚本并使用以下命令调用：

bash <File Name>.sh <Input>

例如，bash Cracking_In_Progress.sh okayerty导致以下输出，以每秒30帧的速度记录：

Haskell（GHC），202字节

import System.Random
import Control.Concurrent
f s|l<-length s=mapM_(\n->putStr('\r':take n s)>>mapM(\_->toEnum<$>randomRIO(32,126))[1..l-n]>>=putStr>>threadDelay 50000)$[n|n<-[0..l-1],f<-[1..20]]++[l]

-5个字节，无需花式回车操作

MATL，26字节

`GZ`:)' ~'olGn4Mk-I$YrhD7M

在线尝试！

以下是脱机编译器的实时输出。请注意，动画GIF是以20 fps录制的，以使其尺寸较小，但实际速度要大得多。

这个怎么运作

           % Implicitly start timer
`          % Do...while
  G        %   Push input
  Z`       %   Push timer's current value, say t
  :)       %   Select the first t elements of the input, with t
           %   implicitly rounded down
  ' ~'     %   Push this string
  o        %   Convert to numbers, i.e. [32 126]
  l        %   Push 1
  Gn       %   Push input size, say n
  4Mk      %   Push floor(t), where t is the same value used above
  k        %   Subtract. Gives n-floor(t)
  I$Yr     %   Generate a row vector of n-floor(t) integers randomly
           %   chosen from 32 to 126
  h        %   Concatenate with the first characters of the input
  D        %   Display
  7M       %   Push the value n-floor(t) used above. This is used
           %   as loop condition: iz zero the loop is exited 
           % Implicit end

Python3，149个 141 139字节

import time,random
i,x=input(),0;l=len(i)
while x<l:x=int(time.clock());print(i[:x]+"".join(chr(random.randint(32,126))for _ in"a"*(l-x)))

来自stdin的输入。

眼睛版本（157字节）：

import time,random
p,i,x=print,input(),0;l=len(i)
while x<l:x=int(time.clock());p(i[:x]+"".join(chr(random.randint(32,126))for _ in"a"*(l-x)),end="\r")
p(i)

Node.js，134个字节

for(s=[...process.argv[2]],n=new(d=Date);s[m=(new d-n)/1e3|0]+console.log(s.map((a,i)=>i<m?a:Buffer([Math.random()*95+32])).join``););

与@ETHproductions类似（借用了他的一些优化方法），但是采用了不同的方法。使用Node Buffer而不是longy 来处理字符生成String.fromCharCode，这有一个附带的好处，那就是让我们使用它map不需要太多的string-> array-> string转换开销。

Python 3中，167个 166字节

import time,random
t=time.time
p,s=input(),t()
while t()-s<len(p):print(p[:int(t()-s)]+''.join(chr(random.randint(32,126))for _ in range(len(p)-int(t()-s))))
print(p)

从标准输入读取输入。171字节的版本在Python 2下运行（替换input为raw_input）：

import time,random
t=time.time
p,s=raw_input(),t()
while t()-s<len(p):print(p[:int(t()-s)]+''.join(chr(random.randint(32,126))for _ in range(len(p)-int(t()-s))))
print(p)

取消高尔夫：

import random
import time

p = input()
start = time.time()
while time.time() - start < len(p): 
    print(
        p[:int(time.time() - start)] + 
        ''.join(chr(random.randint(32, 126)) for _ in range(len(p) - int(time.time()-start)))
    )
print(p)

Dyalog APL，59 58 字节

解

要求⎕IO←0在许多系统上是默认设置。

⊢⊣≢{⍵{≢⎕←⍵↑⍺,⎕UCS 32+?⍵⍴95}⍣{t≤2⊃⎕AI}⍺⊣t←1E3+2⊃⎕AI}¨⍳∘≢↑¨⊂

显示

通过将窗口调整为两行，我们得到了就地转换的错觉：

说明

这是一个匿名函数，将密码作为正确的参数。

⊢⊣ 返回密码并取消结果

≢{... }¨ 下面的函数，将密码的长度作为左参数，应用于每个

 2⊃⎕AI当前运行时间（点亮的第三元件甲 ccount 我载文信息）

 1E3+ 加第二

 t←分配给t

 ⊣ 驳回那个

 ⍵{... 重复}⍣{t≤2⊃⎕AI}⍺应用以下功能（子字符串为⍺，密码长度为⍵），直到正常运行时间达到t

  ⍵⍴95 95重复与密码中的字符相同的次数

  ? 随机整数0 ... 94

  32+加32（因此产生...随机整数，范围为32 ... 126）

  ⎕UCS 转换为Unicode字符

  ⍺, 在当前处理的子字符串之前

  ⍵↑ 只接受与密码中一样多的字符

  ⎕← 在单独的行上输出

  ≢ 返回输出字符串的长度（=密码的长度）

⍳∘≢ 0 ...长度-1

↑¨每个人都从

⊂ 密码

Java，159个字节

s->{for(int i=0,j,l=s.length();i<=l*99;i++){String r=s.substring(0,j=i/20);Thread.sleep(9);for(;j++<l;r+=(char)(32+Math.random()*95));System.out.println(r);}}

与Kevin Cruijssen的答案相同的算法，仅针对Java 8进行了完全优化。

取消高尔夫：

public class Tmp {

  interface X {

    void f(String s) throws Exception;
  }
  static X f = s -> {
    for (int i = 0, j, l = s.length(); i <= l * 20; i++) {
      String r = s.substring(0, j = i / 20);
      Thread.sleep(48);
      for (; j++ < l; r += (char) (32 + Math.random() * 94));
      System.out.println(r);
    }
  };

  public static void main(String[] args) throws Exception {
    f.f("abcde");
  }
}

C＃，203个 197 195 190字节

打高尔夫球：

void F(string s){int l=s.Length,t=0;var w=Stopwatch.StartNew();do{if(w.Elapsed.Seconds>t)t++;Console.WriteLine($"{s.Substring(0,t)}{Path.GetRandomFileName().Substring(0,l-t)}");}while(t<l);}

取消高尔夫：

    void F(string s)
    {
        int l = s.Length, t = 0;
        var w = Stopwatch.StartNew();

        do
        {
            if (w.Elapsed.Seconds > t)
                t++;

            Console.WriteLine($"{s.Substring(0, t)}{Path.GetRandomFileName().Substring(0, l - t)}");
        } while (t < l);
    }

l 存储输入长度。

StopWatch并且Path.GetRandomFileName()是.NET框架的一部分。

EDIT1：隐式Stopwatch声明。

EDIT2：l初始化与声明合并。

EDIT3：谢谢，@ Chris。

Scala中，259 254 248 233 232 231 227 225字节

import scala.concurrent.duration._;(b:String)=>{val d=b.length.seconds.fromNow;while(d.hasTimeLeft)println(b.zipWithIndex.map{case(f,g)=>if(g<b.length-d.timeLeft.toSeconds-1)f else(32+math.random*94)toChar}mkString);print(b)}

取消高尔夫：

import scala.concurrent.duration._;

(b:String) => {
    val d = b.length.seconds.fromNow;
    while(d.hasTimeLeft)
        println(
            b.zipWithIndex.map{
                case(f,g) => 
                    if(g<b.length-d.timeLeft.toSeconds-1)
                        f 
                    else
                        (32+math.random*94)toChar}
            mkString
        );

    print(b)
}

ForceLang，322个 309字节

def s set
s g goto
s W io.writeln
s k io.readln()
s T timer.new()
def a T.poll()
label 1
s P math.floor a.mult 1e-6
if P=k.len
 W k
 exit()
s j 0
s t ""
if P=0
g 4
label 3
s v k.charAt j
s t t+v
s j 1+j
if j-P
g 3
label 4
if j=k.len
 W t
 g 1
s r 94.mult random.rand()
s v string.char 32+r
s t t+v
s j 1+j
g 4

C ++（GCC） ，280个 278字节

#include<iostream>
#include<chrono>
#include<cstdlib>
#include<thread>
int i,n,t,q;void f(std::string s){for(t=s.size(),n=0;n<=t;n++)for(q=n<t?20:1;q--;std::this_thread::sleep_for(std::chrono::milliseconds(50)))for(std::cout<<"\n"<<s.substr(0,i=n);i++<t;)putchar(32+rand()%84);}

在线尝试！

它仅打印20个随机字符串std::chrono::milliseconds，彼此之间等待50个（因此，每秒输出正好20行），然后继续进行下一个“破解”步骤。

前进 244字节

import(."fmt"
."math/rand"
."time")
func a(s string){Seed(Now().Unix())
for i:=0;i<len(s);i++{t:=Now().Truncate(Second).Add(Second)
for Now().Before(t){q:=[]rune(s)
for p:=len(q)-1;p>=i;p--{q[p]=rune(32+Intn(95))}
Println(string(q))}}
Print(s)}

在线尝试！（将结果截断，因此不会显示每个实例）

这是我的第一个Golang答案\ o /

（以30fps拍摄）

怎么样：

func a(s string) {                      //function a
Seed(Now().Unix())                      //Create a seed for the pRNG
for i := 0; i < len(s); i++ {           //set helper var i (this is the number of characters we'll keep)
t := Now().Truncate(Second).Add(Second) //set helper var t = 1 second from now
for Now().Before(t) {                   //while inside that 1 second window
q := []rune(s)                          //put each character in a rune slice and assign that to q
for p := len(q) - 1; p >= i; p-- {      //loops through the rune slice
q[p] = rune(32 + Intn(95))              //replace the character in position p with a random code point in [32,126]
}
Println(string(q))                      //print the rune slice as a string
}
}
Print(s)                                //finally, print the original string
}

PHP，222字节

$a=$argv[1];$c=range(32,126);$t=time();$s=$t;$e=$t+strlen($a);while(time()<=$e){$l=time();$p=$l-$s;$x=substr($a,0,$p);$k=$e-$l;$r='';for($i=$k;$i>0;$i--)$r.=chr($c[rand(0,94)]);$o=$x.$r;echo"$o\n";if($o==$a&&$l==$e)break;}

不打高尔夫球

<?php
$input = $argv[1];
$chars = range(32, 126); // count() is 95

$startTime = time();
$endTime = time() + strlen($input);

while (time() <= $endTime) {
    $plaintextAmountToPrint = time() - $startTime;

    $plain = substr($input, 0, $plaintextAmountToPrint);

    $cryptAmountToPrint = $endTime - time();

    $crypt = '';

    for ($i = $cryptAmountToPrint; $i > 0; $i--)
        $crypt .= chr($chars[rand(0, 94)]);

    $output = $plain . $crypt;

    echo $output . "\n";

    if ($output == $input && time() == $endTime)
        break;
}

（我知道视频很糟糕）

Tcl，295字节

Tcl对我来说是第一个高尔夫。这不是一种很容易打高尔夫的语言，因为这里所有内容都被当作字符串，所以通常必须使用空格...

set l [string length $argv];set s [clock seconds];set r -1;while {$r<$l-1} {puts -nonewline [string range $argv 0 $r];set k $l;while {[set k [expr $k-1]]>$r} {puts -nonewline [format %c [expr int(rand()*95+32)]]};puts "";if {[expr [clock seconds]-$s]>[expr $r+1]} {set r [expr $r+1]}};puts $argv

取消高尔夫：

set l [string length $argv]
set s [clock seconds]
set r -1
while {$r < $l-1} {                                      # loop on time
  puts -nonewline [string range $argv 0 $r]
  set k $l
  while {[set k [expr $k-1]] > $r} {                     # loop on "unfound" chars
    puts -nonewline [format %c [expr int(rand()*95+32)]]
  }
  puts ""
  if {[expr [clock seconds]-$s] > [expr $r+1]} {         # advance time
    set r [expr $r+1]
  }
}
puts $argv

Kotlin，188个字节

打高尔夫球

val x=readLine()!!;val n=System::currentTimeMillis;val t=n();do{val s=(n()-t)/1000;x.mapIndexed{i,c->print(if(i<s)c else((Math.random()*(126-32))+32).toChar())};println()}while(s<x.length)

不打高尔夫球

val input = readLine()!!
val time = System::currentTimeMillis
val startTime = time()
do {
    val crackIndex = (time() - startTime) / 1000
    input.mapIndexed{ i, letter ->
        print(
            if (i < crackIndex) letter else ((Math.random()*(126-32))+32).toChar()
        )
    }
    println()
} while(crackIndex < input.length)

重命名System.currentTimeMillis节省了很多字节！

QBIC，92 88字节

我已经破解了！

t=20;_LA|[a*t-t|B=$left$|(A,b/t)[a|B=B+$CHR$|(_r94|+32)]?$left$|(B,a)~b%t=0|$sleep 1|}?A

这依赖于使用代码文字的QBasic的SLEEP函数$sleep 1|，以及QBasic的LEFT$函数，因为我尚未在QBIC中实现该函数。

通过将所有的替换20为t并将其设置为20，从而设法删除了一些字节。此外，简化了对random和FOR循环的调用。

说明：

' Get cmd line param with 'password' and the length of that string, set t to 20
t=20;_LA|

' loop from 1 (implicitly) to (#chars-1) * 20 cracks per char
[a*-t|

'have our crack-display start with the first N chars of
'the password, where N is the number of seconds passed   
B=$left$|(A,b/t)

' loop to add the 'crack-visual'
' It's too long, but we'll trim it down to the original length
[a|B=B+$CHR$|(_r92|+34)]?$left$|(B,a)

' if we've done 20 cracks, sleep for 1 second
~b%20=0|$sleep 1|}

' We've cracked it!
?A

输出（“ helloworld”的中间部分）

hewnoluZfs
heb!mrc2g@
hee+yh"5ut
he0?V+O)Uu
heqf(#M/BM
hez|DGX%a8
he<_n[6-.+
helkxQ#g%,
hel&^A9$I8
hel43{b5]t
helszK50%F
hel`kdy ;b
hel Vr6Z}s
helLIR7*7o