Rappelez-vous ces programmes de force brute pour craquer mot de passe qui montrent chaque combinaison qu'ils tentent? Plus précisément, à un moment donné, les n premiers caractères sont fixes (ils ont été devinés avec succès) et tous les caractères possibles pour les autres sont testés. Vous en avez probablement déjà vu dans les films ou dans certains logiciels écrits par des personnes qui aiment les interfaces sophistiquées.
Désolé de décevoir, mais nous n'écrirons pas un programme pour déchiffrer un mot de passe, mais un seul pour reproduire la belle sortie.

Défi

Étant donné une chaîne contenant des caractères ascii imprimables mais pas de nouvelles lignes (code ascii 32 à 126 ou correspondant à l'expression régulière ^[ -~]{2,}$), imprimez une sortie en respectant les règles suivantes:

• À la fois t=n seconds, les npremiers caractères imprimés sont les npremiers caractères de la chaîne de saisie.
• Après les ncaractères fixes, vous devez ajouter un caractère aléatoire formé sous forme de chaîne (choisi uniformément de manière pseudo-aléatoire dans la plage unicode   jusqu'à ~(code 32 à 126)) pour former une chaîne de la longueur du premier.
• Vous devriez produire au moins (plus tard plus tard) 20 lignes par seconde: chacune d’elles aura les mêmes npremiers caractères, mais une fin aléatoire différente.

Ce que vous êtes censé faire n'est probablement pas encore très clair, alors prenons un exemple:

Exemple

Je n'imprimerai que 5 lignes différentes pour chaque seconde au lieu des 20 minimum pour que cela soit plus lisible.

Considérez l'entrée abcde.
Pendant la première seconde, une sortie valide peut être quelque chose comme (complètement aléatoire):

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

Ensuite, t=1le premier caractère de chaque chaîne suivante sera a(le premier caractère de l’entrée):

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

Maintenant, t=2les deux premiers caractères seront ab:

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

Maintenant, t=3les trois premiers caractères seront abc:

abcvW
abc3G
abc(g
abc{@
abc@4

Maintenant, t=4les quatre premiers caractères seront abcd:

abcdD
abcdv
abcdj
abcd$
abcd6

Enfin, t=5nous imprimons l’entrée (une seule fois):

abcde

Quelques précisions

• Vous ne devriez pas trop vous préoccuper de la précision de votre langue vers les secondes (c.-à-d. Si votre algorithme est correct mais que votre système / langue manque de précision, tout va bien).
• La première seconde peut être inférieure à une seconde (autrement dit, si vous lancez votre programme pendant une seconde, la première seconde peut ne représenter que le temps restant jusqu'à la fin de la seconde en cours). Autrement dit, vous n'avez pas à attendre le début d'une nouvelle seconde pour commencer à imprimer les sorties.
• Au moins 20 lignes par seconde : la manière la plus naturelle serait une boucle infinie avec un comportement spécial, une par seconde (ou un délai d'expiration, etc.), ce qui donnera probablement quelques milliers de lignes par seconde (et c'est parfaitement correct! ). Mais si vous avez une autre idée, n'hésitez pas à l'utiliser tant que vous imprimez au moins 20 lignes par seconde.
• L'entrée comportera toujours plus de 2 caractères.
• Vous pouvez considérer que la saisie ne comptera pas plus de 30 caractères si cela vous aide. (Mais si ça marche pour les plus longs, c'est pour le mieux)
• Le format de saisie doit être la représentation la plus naturelle d’une chaîne dans votre langue.
• Vous êtes autorisé à imprimer une nouvelle ligne de fin.

Exemple de code

Si vous ne comprenez toujours pas exactement ce que vous devez faire, vous pouvez exécuter le code suivant dans un terminal linux pour voir:

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ère gagnant

C'est du code-golf , donc le code le plus court en octets gagne!

Pyth - 27 à 24 octets

Cela a l'air plutôt cool: D

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

Essayez-le en ligne ici (évidemment pas en temps réel, mais si vous le faites défiler d'une main ferme).

HTML / JavaScript, 170 168 167 octets

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>

Edit: 2 octets sauvegardés grâce à @ETHproductions. Sauvegardé 1 octet grâce à @jrich.

Node, 145 142 octets

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

Cela semble un peu long et il y a probablement une petite place pour jouer au golf. Notez que le point-virgule à la fin est requis; sans cela, le programme génère une erreur de syntaxe car l' forinstruction n'a pas de corps.

Sorties bien plus de 20 lignes par seconde; un petit oiseau m'a dit que c'était environ 12 mille. Voici à quoi ça ressemble dans l'émulateur de terminal ConEmu sur mon ordinateur (enregistré à 30 ips):

05AB1E , 26 octets

Je poste ceci comme une réponse différente par rapport à l'autre réponse 05AB1E car l'approche est différente

.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

Essayez-le en ligne!

BASH, 99 93 92 91 88 octets

avec tr+ head+urandom

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

(merci à @manatwork)

05AB1E, 30 octets

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

Utilise le codage CP-1252 . Essayez-le en ligne!

Aidez-moi à jouer au golf, s'il vous plaît.

C, 182 176 128 126 125 octets

Golfé:

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
}

J'ai entendu dire qu'il était possible de supprimer certaines normes #include, mais je ne pouvais pas le faire fonctionner avec le compilateur MingW GCC que je venais de télécharger. Aussi ne pouvait pas comprendre comment #define b #includeutiliser sans utiliser plus d'espace que cela en valait la peine. Je suis juste un idiot, cela fonctionne très bien sans eux.

Java 7, 271 265 207 octets

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 octets sauvegardés grâce à @ OliverGrégoire . ( N'oubliez pas de faire passer sa réponse encore plus courte à Java 8. )

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

Entrée: abcde
sortie:

WinDbg, 400 391 octets

.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 octets en simplifiant quelques maths

Cela ne semble certainement pas être le genre de choses que WinDbg est censé faire. ;)

La saisie s'effectue en entrant une chaîne ascii dans un emplacement de mémoire et en définissant cette adresse dans le pseudo-registre $t0. Par exemple:

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

Le prng que j'utilise est quel que soit le contenu en mémoire, quelques octets au-delà de la chaîne d'entrée. Chrome.exe apparaît pour remplir l'espace mémoire après 0x2000000avec des octets aléatoires, j'ai donc utilisé un vidage de chrome.exe. Inconnu s'il s'agit d'un uniforme, mais me semble assez aléatoire.

Comment ça fonctionne:

.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

Remarque: Certains octets peuvent être lus en utilisant la jplace de .if's, mais cela le fait fonctionner trop lentement sur ma machine et ne génère donc pas au moins 20 lignes par seconde. Ne sauvegardez donc pas ces octets.

Exemple de sortie: http://pastebin.com/H4H74sAx

R, 138 octets

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

Lit les entrées de stdin.

Compté environ 61 lignes sur ma machine entre chaque lettre supplémentaire dans le "mot de passe".

Bash, 247 245 212 207 octets

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"

Merci beaucoup Bash d'être si sensible aux espaces ...

Quoi qu'il en soit, la sortie est donnée en temps réel sur des lignes séparées. Enregistrer en tant que .shscript et invoquer avec:

bash <File Name>.sh <Input>

Par exemple, les bash Cracking_In_Progress.sh okayertyrésultats suivants, enregistrés à 30 images par seconde:

Haskell (GHC), 202 octets

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 octets sans action de retour en chariot

MATL , 26 octets

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

Essayez-le en ligne!

Vous trouverez ci-dessous la sortie en temps réel du compilateur hors ligne. Notez que le format GIF animé a été enregistré à 20 ips pour conserver une taille réduite, mais la vitesse réelle est beaucoup plus grande.

Comment ça fonctionne

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

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

Entrée de stdin.

Version 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 octets

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

Similaire à @ETHproductions (emprunté certaines de ses optimisations), mais adopte par ailleurs une approche différente. Utilise les nœuds Bufferpour gérer la génération de caractères au lieu des longs caractères String.fromCharCode, ce qui présente l'avantage mapsupplémentaire de nous permettre d'utiliser sans trop de temps supplémentaire la conversion chaîne-> tableau-> chaîne.

Python 3, 167 166 octets

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)

Lit les entrées de stdin. Une version de 171 octets fonctionne sous Python 2 (remplacé inputpar 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 octets

Solution

Nécessite ⎕IO←0ce qui est la valeur par défaut sur de nombreux systèmes.

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

Afficher

En ajustant la fenêtre sur deux lignes, nous obtenons l’illusion d’une transformation sur place:

Explication

Il s'agit d'un train de fonctions anonyme qui prend le mot de passe comme argument correct.

⊢⊣ renvoyer le mot de passe et rejeter le résultat de

≢{... }¨ la fonction ci-dessous, avec la longueur du mot de passe comme argument de gauche, appliquée à chacun des

 2⊃⎕AImise à l' heure (lit. troisième élément de A ccount I nformation)

 1E3+ ajouter une seconde

 t←attribuer cela à t

 ⊣ rejeter que

 ⍵{... }⍣{t≤2⊃⎕AI}⍺appliquer la fonction suivante (avec sous-chaîne comme ⍺ et longueur de mot de passe ⍵ ) à plusieurs reprises jusqu'à ce que le temps atteint jusqu'à t

  ⍵⍴95 95 fois autant de fois qu'il y a de caractères dans le mot de passe

  ? entier aléatoire 0 ... 94

  32+ajouter 32 (donnant ainsi ⍵ nombres entiers aléatoires compris entre 32 et 126)

  ⎕UCS convertir en caractère Unicode

  ⍺, ajouter la sous-chaîne en cours de traitement

  ⍵↑ prenez seulement autant de caractères qu'il y a dans le mot de passe

  ⎕← sortie que sur une ligne séparée

  ≢ retourne la longueur de la chaîne sortie (= la longueur du mot de passe)

⍳∘≢ 0 ... longueur-1

↑¨chacun prenant des personnages de

⊂ le mot de passe

Java, 159 octets

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

Même algorithme que la réponse de Kevin Cruijssen , seulement totalement optimisé pour 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 octets

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

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 stocke la longueur d'entrée.

StopWatchet Path.GetRandomFileName()font partie de .NET Framework.

EDIT1: Stopwatchdéclaration implicite .

EDIT2: linitialisation fusionnée avec déclaration.

EDIT3: Merci, @Chris.

Scala, 259 254 248 233 232 231 227 225 octets

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 octets

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 octets

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

Essayez-le en ligne!

Il imprime simplement 20 chaînes aléatoires en attente de 50 std::chrono::millisecondsentre elles (produisant ainsi exactement 20 lignes par seconde), puis passe à l'étape suivante "de craquage".

Go , 244 octets

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

Essayez-le en ligne! (tronque le résultat pour qu'il ne montre pas toutes les instances)

Ceci est ma première réponse Golang \ o /

(Filmé à 30fps)

Comment:

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 octets

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

(Je sais que la vidéo est de la merde)

Tcl , 295 octets

Premier golf pour moi en Tcl. Ce n'est pas une langue très golfable, puisque tout est traité ici comme une chaîne, les espaces sont donc 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 octets

Golfé

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)

Renommer System.currentTimeMillissauvegardé quelques octets!

QBIC , 92 88 octets

Je l'ai craqué!

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

Cela repose sur la fonction SLEEP de QBasic utilisant le littéral de code $sleep 1|et sur la LEFT$fonction de QBasic car je n'ai pas encore implémenté cette fonction dans QBIC ...

Réussi à supprimer quelques octets en remplaçant tous les caractères 20par tet en les fixant à 20. Aussi, rationalisé un appel en aléatoire et une boucle FOR.

Explication:

' 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 morceau de la section du milieu sur '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