¿Recuerdas esos programas de fuerza bruta para descifrar contraseñas que muestran todas las combinaciones que están intentando? Más precisamente, en un punto, los n primeros caracteres son fijos (se han adivinado con éxito), y se están probando todos los caracteres posibles para los restantes. Probablemente has visto algunas en películas o en algún software escrito por personas a las que les gustan las interfaces sofisticadas.
Lamento decepcionarlo, pero no escribiremos un programa para descifrar la contraseña, solo uno para reproducir la salida agradable.

Desafío

Dada una cadena que contiene caracteres ascii imprimibles pero sin líneas nuevas (código ascii 32 a 126 o que coinciden con la expresión regular ^[ -~]{2,}$), imprima una salida siguiendo estas reglas:

• En ese momento t=n seconds, los nprimeros caracteres impresos son los nprimeros caracteres de la cadena de entrada.
• Después de los ncaracteres fijos, debe agregar un carácter aleatorio formado en cadena (elegido uniformemente pseudoaleatoriamente del rango unicode   a ~(código 32 a 126)) para formar una cadena de la longitud del inicial.
• Debería generar al menos (más sobre eso más adelante) 20 líneas por segundo: cada una de ellas tendrá los mismos nprimeros caracteres, pero un final aleatorio diferente.

Probablemente aún no esté muy claro lo que se supone que debes hacer, así que veamos un ejemplo:

Ejemplo

Imprimiré solo 5 líneas diferentes por cada segundo en lugar del mínimo de 20 solo para que sea más legible.

Considere la entrada abcde.
Durante el primer segundo, una salida válida puede ser algo como (completamente al azar):

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

Entonces, t=1el primer carácter de cada cadena siguiente será a(el primer carácter de la entrada):

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

Ahora, t=2los dos primeros caracteres serán ab:

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

Ahora, t=3los primeros tres caracteres serán abc:

abcvW
abc3G
abc(g
abc{@
abc@4

Ahora, t=4los primeros cuatro caracteres serán abcd:

abcdD
abcdv
abcdj
abcd$
abcd6

Finalmente, t=5imprimimos la entrada (solo una vez):

abcde

Algunas precisiones

• No debe molestarse demasiado con la precisión de su idioma hacia los segundos (es decir, si su algoritmo es correcto pero su sistema / idioma carece de precisión, entonces está bien).
• El primer segundo puede ser más corto que un segundo (es decir, si inicia su programa durante un segundo, el primer segundo puede ser solo el tiempo restante hasta el final del segundo actual). O dicho de otra manera, no tiene que esperar el inicio de un nuevo segundo para comenzar a imprimir las salidas.
• Al menos 20 líneas por segundo : la forma más natural sería un bucle infinito con un comportamiento especial, uno por segundo (o un tiempo de espera, o lo que sea), por lo que resultará en unos pocos miles de líneas por segundo (¡y eso está perfectamente bien! ) Pero si tiene otra idea, siéntase libre de usarla siempre que imprima al menos 20 líneas por segundo.
• La entrada siempre tendrá más de 2 caracteres de longitud.
• Puede considerar que la entrada no tendrá más de 30 caracteres si ayuda. (Pero si funciona para los más largos, es lo mejor)
• El formato de entrada debe ser la representación más natural de una cadena en su idioma.
• Se le permite imprimir una nueva línea final.

Ejemplo de código

Si aún no comprende exactamente lo que tiene que hacer, puede ejecutar el siguiente código en un terminal de 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\!"

Criterio ganador

Este es el código de golf , por lo que gana el código más corto en bytes.

Pyth - 27 24 bytes

Esto realmente se ve muy bien: D

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

Pruébelo en línea aquí (obviamente no en tiempo real, pero si lo desplaza hacia abajo con una mano 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: Guardado 2 bytes gracias a @ETHproductions. Guardado 1 byte gracias a @jrich.

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

Esto parece un poco largo, y probablemente haya un pequeño espacio para jugar al golf. Tenga en cuenta que se requiere el punto y coma al final; sin él, el programa arroja un error de sintaxis porque la fordeclaración no tiene cuerpo.

Produce más de 20 líneas por segundo; un pajarito me dijo que son aproximadamente 12 mil. Así es como se ve en el emulador de terminal ConEmu en mi computadora (grabado a 30 fps):

05AB1E , 26 bytes

Publico esto como una respuesta diferente con respecto a la otra respuesta 05AB1E ya que el enfoque es 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

Pruébalo en línea!

BASH, 99 93 92 91 88 bytes

con tr+ head+urandom

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

(gracias a @manatwork)

05AB1E, 30 bytes

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

Utiliza la codificación CP-1252 . Pruébalo en línea!

Por favor, ayúdame a jugar golf.

C, 182 176 128 126 125 bytes

Golfizado:

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

Sin golf:

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

Escuché que es posible eliminar algunos #includes estándar , pero no pude hacer que funcione en el compilador MingW GCC que acabo de descargar. Tampoco podía imaginar cómo hacerlo #define b #includesin usar más espacio del que valía la pena. Solo soy un idiota, funciona bien sin ellos.

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 guardados gracias a @ OliverGrégoire . ( No olvides votar su respuesta Java 8 aún más corta ) .

Sin golf:

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
Salida:

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 algunas matemáticas

Esto definitivamente no parece ser el tipo de cosas que WinDbg pretende hacer. ;)

La entrada se toma ingresando una cadena ASCII en una ubicación de memoria y configurando esa dirección en el pseudo-registro $t0. P.ej:

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

El prng que estoy usando es cualquiera que sea el contenido en memoria, algunos bytes más allá de la cadena de entrada. Chrome.exe parece llenar el espacio de memoria después 0x2000000con bytes de aspecto aleatorio suficiente, así que utilicé un volcado de chrome.exe. Se desconoce si esto es uniforme, pero me parece lo suficientemente aleatorio.

Cómo 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: Algunos bytes se pueden jugar usando en jlugar de los .if's, pero eso hace que se ejecute muy lentamente en mi máquina, por lo que no genera al menos 20 líneas por segundo, por lo que no guarda esos bytes.

Salida de muestra: 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="")}

Lee la entrada de stdin.

Conté aproximadamente 61 líneas en mi máquina entre cada letra adicional en la "contraseña".

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"

Muchas gracias Bash por ser tan sensible al espacio en blanco ...

De todos modos, la salida se da en tiempo real en líneas separadas. Guardar como .shscript e invocar con:

bash <File Name>.sh <Input>

Por ejemplo, bash Cracking_In_Progress.sh okayertyda como resultado la siguiente salida, grabada a 30 cuadros 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 sin acción de retorno de carro elegante

MATL , 26 bytes

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

Pruébalo en línea!

A continuación se muestra la salida en tiempo real del compilador fuera de línea. Tenga en cuenta que el GIF animado se grabó a 20 fps para mantener su tamaño pequeño, pero la velocidad real es mucho mayor.

Cómo 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.

Versión de 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)

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

Similar a @ETHproductions (tomó prestadas algunas de sus optimizaciones), pero por lo demás adopta un enfoque diferente. Utiliza los nodos Bufferpara manejar la generación de caracteres en lugar de los largos String.fromCharCode, lo que tiene el beneficio adicional de permitirnos usar mapsin demasiada sobrecarga de conversión de cadena-> matriz-> cadena.

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)

Lee la entrada de stdin. Una versión de 171 bytes se ejecuta en Python 2 (reemplazado 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)

Sin golf:

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

Solución

Requiere ⎕IO←0cuál es el predeterminado en muchos sistemas.

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

Monitor

Al ajustar la ventana a dos líneas, obtenemos la ilusión de una transformación in situ:

Explicación

Este es un tren de funciones anónimo que toma la contraseña como argumento correcto.

⊢⊣ devolver la contraseña y descartar el resultado de

≢{... }¨ la siguiente función, con la longitud de la contraseña como argumento izquierdo, aplicada a cada uno de

 2⊃⎕AIcorriente hasta los tiempos (lit. tercer elemento de un UENTA I nformación)

 1E3+ agrega un segundo

 t←asignar eso a t

 ⊣ descartar eso

 ⍵{... }⍣{t≤2⊃⎕AI}⍺aplique la siguiente función (con una subcadena como ⍺ y la longitud de la contraseña como ⍵ ) repetidamente hasta que el tiempo de actividad alcance t

  ⍵⍴95 95 repetido tantas veces como haya caracteres en la contraseña

  ? entero aleatorio 0 ... 94

  32+suma 32 (lo que produce ⍵ enteros aleatorios en el rango 32 ... 126)

  ⎕UCS convertir a carácter Unicode

  ⍺, anteponer la subcadena procesada actualmente

  ⍵↑ tomar solo tantos caracteres como haya en la contraseña

  ⎕← salida que en una línea separada

  ≢ devolver la longitud de la cadena de salida (= la longitud de la contraseña)

⍳∘≢ 0 ... longitud-1

↑¨cada uno tomando personajes de

⊂ la contraseña

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

Mismo algoritmo que la respuesta de Kevin Cruijssen , solo totalmente optimizado para Java 8.

Sin golf:

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

Golfizado:

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

Sin golf:

    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 almacena la longitud de entrada.

StopWatchy Path.GetRandomFileName()son partes de .NET framework.

EDIT1: StopwatchDeclaración implícita .

EDIT2: linicialización fusionada con declaración.

EDITAR3: Gracias, @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)}

Sin golf:

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

Pruébalo en línea!

Simplemente imprime 20 cadenas aleatorias esperando 50 std::chrono::millisecondsentre sí (generando exactamente 20 líneas por segundo) y luego continúa con el siguiente paso de "craqueo".

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

Pruébalo en línea! (trunca el resultado para que no muestre todas las instancias)

Esta es mi primera respuesta de Golang \ o /

(Filmado a 30 fps)

Cómo:

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

Sin golf

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

(Sé que el video es una mierda)

Tcl , 295 bytes

Primero golf para mí en Tcl. No es un lenguaje muy golfable, ya que aquí todo se trata como cadenas, por lo que el espacio en blanco suele ser obligatorio ...

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

Sin golf:

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

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)

Sin golf

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)

¡El cambio de nombre System.currentTimeMillisahorró bastantes bytes!

QBIC , 92 88 bytes

¡Lo he roto!

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

Esto se basa en la función SLEEP de QBasic usando el código literal $sleep 1|, y en la LEFT$función de QBasic porque todavía no he implementado esa función en QBIC ...

Se las arregló para raspar algunos bytes sustituyendo todos los 20's ty configurándolo en 20. Además, simplificó una llamada al azar y un bucle FOR.

Explicación:

' 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

Salida (una parte de la sección central en '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