Ricordi quei programmi a forza bruta per decifrare la password che mostra tutte le combinazioni che stanno provando? Più precisamente, ad un certo punto, i primi n caratteri sono stati corretti (sono stati indovinati con successo), e tutti i caratteri possibili per i restanti vengono testati. Probabilmente ne hai visti alcuni nei film o in alcuni software scritti da persone a cui piacciono le interfacce fantasiose.
Ci dispiace deludere, ma non scriveremo un programma per decifrare la password, solo uno per riprodurre l'output gradevole.

Sfida

Data una stringa contenente caratteri ASCII stampabili ma nessuna nuova riga (codice ASCII da 32 a 126 o corrispondente al regex ^[ -~]{2,}$), stampare un output seguendo queste regole:

• Al momento t=n seconds, i nprimi caratteri stampati sono i nprimi caratteri della stringa di input.
• Dopo i ncaratteri fissi, è necessario aggiungere una stringa di caratteri casuali (scelti uniformemente pseudo-casuali dall'intervallo unicode   a ~(codici da 32 a 126)) per formare una stringa della lunghezza di quella iniziale.
• Dovresti produrre almeno (più avanti) più di 20 righe al secondo: ognuna di esse avrà gli stessi nprimi caratteri, ma una diversa fine casuale.

Probabilmente non è ancora chiaro cosa dovresti fare, quindi facciamo un esempio:

Esempio

Stamperò solo 5 righe diverse per ogni secondo anziché il minimo 20 solo per renderlo più leggibile.

Considera l'input abcde.
Durante il primo secondo, un output valido può essere qualcosa di simile (completamente casuale):

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

Quindi, t=1il primo carattere di ogni stringa seguente sarà a(il primo carattere dell'input):

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

Ora, t=2i primi due personaggi saranno ab:

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

Ora, t=3i primi tre personaggi saranno abc:

abcvW
abc3G
abc(g
abc{@
abc@4

Ora, t=4i primi quattro personaggi saranno abcd:

abcdD
abcdv
abcdj
abcd$
abcd6

Infine, t=5stampiamo l'input (solo una volta):

abcde

Alcune precisazioni

• Non dovresti preoccuparti troppo della precisione della tua lingua verso i secondi (es. Se l'algoritmo è corretto ma il tuo sistema / linguaggio manca di precisione, allora va bene).
• Il primo secondo può essere più breve di un secondo (ovvero, se si avvia il programma durante un secondo, il primo secondo può essere solo il tempo rimanente fino alla fine del secondo corrente). O in altre parole, non è necessario attendere l'inizio di un nuovo secondo per iniziare a stampare gli output.
• Almeno 20 righe al secondo : il modo più naturale sarebbe un loop infinito con un comportamento speciale uno al secondo (o un timeout, o qualsiasi altra cosa), quindi ciò comporterà probabilmente qualche migliaio di righe al secondo (e va benissimo! ). Ma se hai un'altra idea, sentiti libero di usarla fintanto che stampi almeno 20 righe al secondo.
• L'input avrà sempre una lunghezza superiore a 2 caratteri.
• Puoi considerare che l'input non sarà più lungo di 30 caratteri se aiuta. (Ma se funziona per quelli più lunghi, è per il meglio)
• Il formato di input dovrebbe essere la rappresentazione più naturale di una stringa nella tua lingua.
• Hai il permesso di stampare una nuova riga finale.

Esempio di codice

Se ancora non capisci esattamente cosa devi fare, puoi vedere il seguente codice in un terminale Linux per vedere:

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

Criterio vincente

Questo è code-golf , quindi vince il codice più corto in byte!

Pyth - 27 24 byte

In realtà sembra piuttosto bello: D

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

Provalo online qui (ovviamente non in tempo reale, ma se lo scorri verso il basso con una mano ferma).

HTML / JavaScript, 170 168 167 byte

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>

Modifica: salvato 2 byte grazie a @ETHproductions. Salvato 1 byte grazie a @jrich.

Nodo, 145 142 byte

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

Sembra un po 'lungo e probabilmente c'è una piccola stanza per giocare a golf. Si noti che è richiesto il punto e virgola alla fine; senza di essa il programma genera un errore di sintassi perché l' foristruzione non ha un corpo.

Emette più di 20 linee al secondo; un uccellino mi ha detto che sono circa 12 mila. Ecco come appare nell'emulatore di terminale ConEmu sul mio computer (registrato a 30 fps):

05AB1E , 26 byte

Inserisco questa come una risposta diversa rispetto all'altra risposta 05AB1E poiché l'approccio è diverso

.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

Provalo online!

BASH, 99 93 92 91 88 byte

con tr+ head+urandom

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

(grazie a @manatwork)

05AB1E, 30 byte

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

Utilizza la codifica CP-1252 . Provalo online!

Per favore, aiutami a giocare a golf.

C, 182 176 128 126 125 byte

golfed:

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
}

Ho sentito che è possibile eliminare alcuni standard #include, ma non sono riuscito a farlo funzionare sul compilatore GCC MingW che ho appena scaricato. Inoltre non riuscivo a capire come fare #define b #includesenza usare più spazio di quanto valesse. Sono solo un idiota, funziona bene senza di loro.

Java 7, 271 265 207 byte

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 byte salvati grazie a @ OliverGrégoire . ( Non dimenticare di votare la sua risposta Java 8 ancora più breve. )

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

Ingresso: abcde
Uscita:

WinDbg, 400 391 byte

.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 byte semplificando alcuni calcoli matematici

Questo sicuramente non sembra essere il tipo di cosa che WinDbg è destinato a fare. ;)

L'input viene preso inserendo una stringa ASCII in una posizione di memoria e impostando tale indirizzo sullo pseudo-registro $t0. Per esempio:

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

Il prng che sto usando è qualunque sia il contenuto in memoria, alcuni byte oltre la stringa di input. Chrome.exe sembra riempire lo spazio di memoria dopo 0x2000000con byte abbastanza casuali, quindi ho usato un dump di chrome.exe. Sconosciuto se questo è uniforme, ma sembra abbastanza casuale per me.

Come funziona:

.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: alcuni byte potrebbero essere giocati a golf usando al jposto di quelli .if, ma ciò fa sì che funzioni troppo lentamente sulla mia macchina in modo che non generi almeno 20 linee al secondo, quindi non si salvano quei byte.

Esempio di output: http://pastebin.com/H4H74sAx

R, 138 byte

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

Legge input da stdin.

Ho contato circa 61 righe sulla mia macchina tra ogni lettera aggiuntiva nella "password".

Bash, 247 245 212 207 byte

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"

Grazie mille Bash per essere così sensibile agli spazi bianchi ...

Comunque, l'output è dato in tempo reale su linee separate. Salva come .shscript e invoca con:

bash <File Name>.sh <Input>

Ad esempio, bash Cracking_In_Progress.sh okayertyproduce il seguente output, registrato a 30 frame al secondo:

Haskell (GHC), 202 byte

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 byte senza azione di ritorno del carrello di fantasia

MATL , 26 byte

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

Provalo online!

Di seguito è riportato l'output in tempo reale dal compilatore offline. Si noti che la GIF animata è stata registrata a 20 fps per mantenere le dimensioni ridotte, ma la velocità effettiva è molto maggiore.

Come funziona

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

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

Input da stdin.

Versione Eyes (157 byte):

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 byte

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

Simile a @ETHproductions (preso in prestito alcune delle sue ottimizzazioni), ma per il resto ha un approccio diverso. Utilizza i Nodi Bufferper gestire la generazione dei caratteri anziché i lunghi String.fromCharCode, il che ha il vantaggio secondario di farci usare mapsenza un sovraccarico di conversione string-> array-> string.

Python 3, 167 166 byte

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)

Legge input da stdin. Una versione da 171 byte funziona con Python 2 (sostituita inputcon 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 byte

Soluzione

Richiede il ⎕IO←0valore predefinito su molti sistemi.

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

Schermo

Regolando la finestra su due linee, otteniamo l'illusione di una trasformazione sul posto:

Spiegazione

Questo è un treno di funzioni anonimo che accetta la password come argomento corretto.

⊢⊣ restituire la password e chiudere il risultato di

≢{... }¨ la funzione di seguito, con la lunghezza della password come argomento sinistro, applicata a ciascuna di

 2⊃⎕AIup-time attuale (lett. terzo elemento di informazioni A ccount I )

 1E3+ aggiungere un secondo

 t←assegnalo a t

 ⊣ respingilo

 ⍵{... }⍣{t≤2⊃⎕AI}⍺applica ripetutamente la seguente funzione (con sottostringa come ⍺ e lunghezza password come ⍵ ) fino a quando il tempo di attività raggiunge t

  ⍵⍴95 95 ripetuto tante volte quanti sono i caratteri nella password

  ? numero intero casuale 0 ... 94

  32+aggiungere 32 (ottenendo così ⍵ numeri casuali nell'intervallo 32 ... 126)

  ⎕UCS converti in carattere Unicode

  ⍺, antepone la sottostringa attualmente elaborata

  ⍵↑ accetta solo il numero di caratteri presente nella password

  ⎕← output che su una riga separata

  ≢ restituisce la lunghezza della stringa emessa (= la lunghezza della password)

⍳∘≢ 0 ... lunghezza-1

↑¨ognuno prende i personaggi da

⊂ la password

Java, 159 byte

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

Stesso algoritmo della risposta di Kevin Cruijssen , completamente totalmente ottimizzato per 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 byte

golfed:

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 memorizza la lunghezza dell'input.

StopWatche Path.GetRandomFileName()fanno parte di .NET framework.

EDIT1: Stopwatchdichiarazione implicita .

EDIT2: linizializzazione unita alla dichiarazione.

EDIT3: Grazie, @Chris.

Scala, 259 254 248 233 232 231 227 225 byte

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 byte

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 byte

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

Provalo online!

Stampa solo 20 stringhe casuali in attesa di 50 std::chrono::millisecondstra loro (in tal modo emettendo esattamente 20 righe al secondo) e quindi procede al passaggio successivo di "cracking".

Vai , 244 byte

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

Provalo online! (tronca il risultato in modo che non mostri tutte le istanze)

Questa è la mia prima risposta Golang \ o /

(Girato a 30 fps)

Come:

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 byte

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

(so che il video è una schifezza)

Tcl , 295 byte

Primo golf per me a Tcl. Non è un linguaggio molto golfabile, dal momento che tutto è trattato come stringhe qui, quindi gli spazi bianchi sono di solito un must ...

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 byte

golfed

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)

La ridenominazione ha System.currentTimeMillissalvato parecchi byte!

QBIC , 92 88 byte

L'ho rotto!

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

Questo si basa sulla funzione SLEEP di QBasic usando il codice letterale $sleep 1|e sulla LEFT$funzione di QBasic perché non ho ancora implementato quella funzione in QBIC ...

Riuscito a raschiare pochi byte sostituendo tutte le 20's per te l'impostazione che a 20. Inoltre, razionalizzato una chiamata a caso e un ciclo for.

Spiegazione:

' 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

Output (un pezzo della sezione centrale di "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