Lembre-se daqueles programas de força bruta para quebrar a senha que mostram todas as combinações que estão tentando? Mais precisamente, em um ponto, os n primeiros caracteres são corrigidos (foram adivinhados com sucesso) e todos os caracteres possíveis para os demais estão sendo testados. Você provavelmente já viu alguns filmes ou softwares escritos por pessoas que gostam de interfaces sofisticadas.
Desculpe desapontar, mas não escreveremos um programa para quebrar a senha, apenas um para reproduzir a boa saída.

Desafio

Dada uma sequência contendo caracteres ascii imprimíveis, mas sem novas linhas (código ascii 32 a 126 ou correspondendo ao regex ^[ -~]{2,}$), imprima uma saída seguindo estas regras:

• No momento t=n seconds, os nprimeiros caracteres impressos são os nprimeiros caracteres da sequência de entrada.
• Após os ncaracteres fixos, você deve anexar um caractere aleatório formado por sequência (escolhido uniformemente pseudo-aleatoriamente do intervalo unicode   para ~(código 32 a 126)) para formar uma sequência com o comprimento do inicial.
• Você deve produzir pelo menos (mais sobre isso mais tarde) 20 linhas a cada segundo: cada uma delas terá os mesmos nprimeiros caracteres, mas com um final aleatório diferente.

Provavelmente ainda não está muito claro o que você deve fazer, então vamos dar um exemplo:

Exemplo

Imprimo apenas 5 linhas diferentes a cada segundo, em vez dos 20 mínimos, apenas para torná-lo mais legível.

Considere a entrada abcde.
Durante o primeiro segundo, uma saída válida pode ser algo como (completamente aleatório):

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

Então, t=1o primeiro caractere de cada sequência a seguir será a(o primeiro caractere da entrada):

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

Agora, t=2os dois primeiros caracteres serão ab:

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

Agora, t=3os três primeiros caracteres serão abc:

abcvW
abc3G
abc(g
abc{@
abc@4

Agora, t=4os quatro primeiros caracteres serão abcd:

abcdD
abcdv
abcdj
abcd$
abcd6

Por fim, t=5imprimimos a entrada (apenas uma vez):

abcde

Algumas precisões

• Você não deve se preocupar muito com a precisão do seu idioma em segundos (ou seja, se o seu algoritmo estiver correto, mas o seu sistema / idioma não tiver precisão, tudo bem).
• O primeiro segundo pode ter menos de um segundo (ou seja, se você iniciar o programa durante um segundo, o primeiro segundo poderá ser apenas o tempo restante até o final do segundo atual). Em outras palavras, você não precisa esperar o início de um novo segundo para começar a imprimir as saídas.
• Pelo menos 20 linhas por segundo : a maneira mais natural seria um loop infinito com um comportamento especial a cada segundo (ou um tempo limite ou o que for), de modo que resultará provavelmente em alguns milhares de linhas por segundo (e isso é perfeitamente bom! ) Mas se você tiver outra ideia, fique à vontade para usá-la, desde que imprima pelo menos 20 linhas por segundo.
• A entrada sempre terá mais de 2 caracteres.
• Você pode considerar que a entrada não terá mais de 30 caracteres, se ajudar. (Mas se funcionar para os mais longos, é o melhor)
• O formato de entrada deve ser a representação mais natural de uma string no seu idioma.
• Você tem permissão para imprimir uma nova linha à direita.

Exemplo de código

Se você ainda não entender exatamente o que precisa fazer, execute o seguinte código em um terminal linux para ver:

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

Critério de vitória

Isso é código-golfe , então o código mais curto em bytes ganha!

Pitão - 27 24 bytes

Isso realmente parece muito legal: D

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

Experimente on-line aqui (obviamente não em tempo real, mas se você rolar para baixo com uma mão firme).

HTML / JavaScript, 170 168 167 bytes

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>

Editar: salvou 2 bytes graças a @ETHproductions. Guardou 1 byte graças a @jrich.

Nó, 145 142 bytes

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

Parece um pouco longo, e provavelmente há um pouco de espaço para jogar golfe. Observe que o ponto e vírgula no final é necessário; sem ele, o programa lança um erro de sintaxe porque a forinstrução não tem corpo.

Produz muito mais de 20 linhas por segundo; um passarinho me disse que são aproximadamente 12 mil. Veja como fica no emulador de terminal ConEmu no meu computador (gravado a 30 fps):

05AB1E , 26 bytes

Coloco isso como uma resposta diferente em relação à outra resposta 05AB1E, pois a abordagem é diferente

.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

Experimente online!

BASH, 99 93 92 91 88 bytes

com tr+ head+urandom

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

(thx. a @manatwork)

05AB1E, 30 bytes

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

Usa a codificação CP-1252 . Experimente online!

Por favor, me ajude a resolver isso.

C, 182 176 128 126 125 bytes

Golfe:

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

Ungolfed:

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

Ouvi dizer que é possível descartar alguns #includes padrão , mas não consegui fazê-lo funcionar no compilador MingW GCC que acabei de baixar. Também não conseguia descobrir como #define b #includeusar sem usar mais espaço do que valia a pena. Eu sou apenas um idiota, funciona bem sem eles.

Java 7, 271 265 207 bytes

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

-58 bytes salvos graças ao @ OliverGrégoire . ( Não esqueça de votar em sua resposta Java 8 ainda mais curta. )

Ungolfed:

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

Entrada: abcde
Saída:

WinDbg, 400 391 bytes

.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 bytes, simplificando um pouco de matemática

Definitivamente, isso não parece ser o tipo de coisa que o WinDbg pretende fazer. ;)

A entrada é obtida inserindo uma string ascii em um local de memória e configurando esse endereço para o pseudo-registro $t0. Por exemplo:

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

O prng que estou usando é qualquer que seja o conteúdo da memória, alguns bytes após a string de entrada. Chrome.exe parece preencher o espaço de memória depois 0x2000000com bytes com aparência aleatória, então usei um despejo de chrome.exe. Desconhecido se isso é uniforme, mas parece aleatório o suficiente para mim.

Como funciona:

.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

Nota: Alguns bytes podem ser transferidos para o golfe usando-os em jvez dos .if, mas isso faz com que ele seja executado muito lentamente na minha máquina, para que não produza pelo menos 20 linhas por segundo, para não salvar esses bytes.

Saída de amostra: http://pastebin.com/H4H74sAx

R, 138 bytes

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="")}

Lê a entrada de stdin.

Contou aproximadamente 61 linhas na minha máquina entre cada letra adicional na "senha".

Bash, 247 245 212 207 bytes

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"

Muito obrigado Bash por ser tão sensível a espaços em branco ...

De qualquer forma, a saída é fornecida em tempo real em linhas separadas. Salve como um .shscript e chame com:

bash <File Name>.sh <Input>

Por exemplo, bash Cracking_In_Progress.sh okayertyresulta na seguinte saída, registrada em 30 quadros por segundo:

Haskell (GHC), 202 bytes

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 bytes sem ação de retorno de carro sofisticado

MATL , 26 bytes

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

Experimente online!

Abaixo está a saída em tempo real do compilador offline. Observe que o GIF animado foi gravado a 20 qps para manter seu tamanho pequeno, mas a velocidade real é muito maior.

Como funciona

           % 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 bytes

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

Entrada de stdin.

Versão Eyes (157 bytes):

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 bytes

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

Semelhante ao @ETHproductions (emprestou algumas de suas otimizações), mas, por outro lado, adota uma abordagem diferente. Usa Nó Bufferpara lidar com a geração de caracteres em vez de demorada String.fromCharCode, o que tem o benefício de nos deixar usar mapsem muita sobrecarga de conversão de string-> array-> string.

Python 3, 167 166 bytes

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)

Lê a entrada de stdin. Uma versão de 171 bytes é executada no Python 2 (substituído inputpor 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)

Ungolfed:

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 bytes

Solução

Requer ⎕IO←0qual é o padrão em muitos sistemas.

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

Exibição

Ao ajustar a janela para duas linhas, obtemos a ilusão de uma transformação no local:

Explicação

Este é um trem de funções anônimas que usa a senha como argumento correto.

⊢⊣ retornar a senha e descartar o resultado de

≢{... }¨ a função abaixo, com o comprimento da senha como argumento à esquerda, aplicada a cada um dos

 2⊃⎕AIatual up-time (lit. terceiro elemento de A ccount I nformação)

 1E3+ adicione um segundo

 t←atribuir isso a t

 ⊣ descartar que

 ⍵{... }⍣{t≤2⊃⎕AI}⍺aplique a seguinte função (com sub-string como ⍺ e comprimento da senha como ⍵ ) repetidamente até que o tempo de atividade atinja t

  ⍵⍴95 95 repetido quantas vezes houver caracteres na senha

  ? número inteiro aleatório 0 ... 94

  32+adicionar 32 (produzindo assim ⍵ inteiros aleatórios no intervalo de 32 ... 126)

  ⎕UCS converter para caractere Unicode

  ⍺, preceder a sub-cadeia atualmente processada

  ⍵↑ use apenas quantos caracteres houver na senha

  ⎕← saída que em uma linha separada

  ≢ retorna o comprimento da string gerada (= o comprimento da senha)

⍳∘≢ 0 ... comprimento-1

↑¨cada um tirando caracteres de

⊂ a senha

Java, 159 bytes

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

Mesmo algoritmo que a resposta de Kevin Cruijssen , totalmente otimizado para Java 8.

Ungolfed:

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 bytes

Golfe:

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

Ungolfed:

    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 armazena o comprimento da entrada.

StopWatche Path.GetRandomFileName()fazem parte do .NET framework.

EDIT1: Stopwatchdeclaração implícita .

EDIT2: linicialização mesclada com declaração.

EDIT3: Obrigado, Chris.

Scala, 259 254 248 233 232 231 227 225 bytes

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

Ungolfed:

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 bytes

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 bytes

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

Experimente online!

Ele apenas imprime 20 seqüências aleatórias esperando 50 std::chrono::millisecondsentre si (produzindo exatamente 20 linhas por segundo) e depois prossegue para a próxima etapa de "quebra".

Go , 244 bytes

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

Experimente online! (trunca o resultado para não mostrar todas as instâncias)

Esta é a minha primeira resposta Golang \ o /

(Filmado a 30fps)

Como:

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 bytes

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

Ungolfed

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

(eu sei que o vídeo é uma porcaria)

Tcl , 295 bytes

Primeiro golfe para mim em Tcl. Não é uma linguagem muito fácil de jogar, já que tudo é tratado como seqüências de caracteres aqui, então espaço em branco é geralmente uma obrigação ...

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

Ungolfed:

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 bytes

Golfe

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)

Ungolfed

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)

Mudar o nome System.currentTimeMillissalvou alguns bytes!

QBIC , 92 88 bytes

Eu quebrei!

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

Isso depende da função SLEEP do QBasic usando o literal de código $sleep 1|e da LEFT$função do QBasic porque eu ainda não implementei essa função no QBIC ...

Dirigido para raspar alguns bytes substituindo todo o 20's para te configuração que a 20. Além disso, simplificada uma chamada para aleatório e um loop for.

Explicação:

' 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

Saída (uma parte da seção do meio em '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