Pamiętasz te brutalne programy, które łamią hasło, które pokazują każdą kombinację, której próbują? Dokładniej, w pewnym momencie n pierwszych znaków jest naprawionych (zgadywano z powodzeniem) i testowany jest każdy możliwy znak dla pozostałych. Prawdopodobnie widziałeś niektóre w filmach lub w oprogramowaniu napisanym przez ludzi, którzy lubią fantazyjne interfejsy.
Przykro nam, że rozczarowałem, ale nie napiszemy programu do łamania hasła, tylko jednego do odtworzenia ładnego wyniku.

Wyzwanie

Biorąc pod uwagę ciąg znaków zawierający drukowalne znaki ascii, ale bez znaków nowej linii (kod ascii 32 do 126 lub zgodny z wyrażeniem regularnym ^[ -~]{2,}$), wydrukuj wynik zgodnie z następującymi regułami:

• W czasie t=n seconds, gdy npierwsze znaki drukowane są npierwsze znaki ciągu wejściowego.
• Po nustalonych znakach należy dołączyć ciąg znaków utworzony losowo (wybrany jednolicie pseudolosowo z zakresu Unicode   do ~(kod 32 do 126)), aby utworzyć ciąg o długości początkowej.
• Powinieneś wypisywać co najmniej (więcej na ten temat później) 20 linii na sekundę: każdy z nich będzie miał te same npierwsze znaki, ale inny losowy koniec.

Prawdopodobnie nie jest jeszcze bardzo jasne, co należy zrobić, więc przejdźmy przez przykład:

Przykład

Wydrukuję tylko 5 różnych wierszy na każdą sekundę zamiast 20 minimum, aby było bardziej czytelne.

Rozważ dane wejściowe abcde.
W ciągu pierwszej sekundy prawidłowym wyjściem może być coś takiego (całkowicie losowy):

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

Następnie t=1pierwszym znakiem każdego następnego ciągu będzie a(pierwszy znak wejścia):

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

Teraz t=2dwie pierwsze postacie będą ab:

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

Teraz t=3pierwsze trzy postacie będą abc:

abcvW
abc3G
abc(g
abc{@
abc@4

Teraz t=4pierwsze cztery znaki to abcd:

abcdD
abcdv
abcdj
abcd$
abcd6

Na koniec t=5wypisujemy dane wejściowe (tylko raz):

abcde

Kilka szczegółów

• Nie powinieneś zbytnio przejmować się precyzją języka w sekundach (tj. Jeśli twój algorytm jest poprawny, ale twój system / język nie ma precyzji, to jest w porządku).
• Pierwsza sekunda może być krótsza niż jedna sekunda (to znaczy, jeśli uruchomisz program w ciągu sekundy, pierwszą sekundą może być pozostały czas do końca bieżącej sekundy). Innymi słowy, nie musisz czekać na początek nowej sekundy, aby rozpocząć drukowanie wyników.
• Co najmniej 20 linii na sekundę : Bardziej naturalną metodą byłaby nieskończona pętla ze specjalnym zachowaniem co sekundę (lub przekroczenie limitu czasu lub cokolwiek innego), dzięki czemu powstanie prawdopodobnie kilka tysięcy linii na sekundę (i to doskonale! ). Ale jeśli masz inny pomysł, możesz go używać, o ile drukujesz co najmniej 20 linii na sekundę.
• Dane wejściowe zawsze będą miały więcej niż 2 znaki.
• Możesz wziąć pod uwagę, że dane wejściowe nie będą dłuższe niż 30 znaków, jeśli to pomoże. (Ale jeśli działa na dłuższe, to na najlepsze)
• Format wejściowy powinien być najbardziej naturalną reprezentacją ciągu w twoim języku.
• Możesz wydrukować końcowy znak nowej linii.

Przykład kodu

Jeśli nadal nie rozumiesz dokładnie, co musisz zrobić, możesz uruchomić następujący kod w terminalu Linux, aby zobaczyć:

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

Kryterium wygranej

To jest golf golfowy , więc wygrywa najkrótszy kod w bajtach!

Pyth - 27 24 bajtów

To naprawdę wygląda całkiem fajnie: D

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

Wypróbuj online tutaj (oczywiście nie w czasie rzeczywistym, ale jeśli przewiniesz go pewną ręką).

HTML / JavaScript, 170 168 167 bajtów

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>

Edycja: Zapisano 2 bajty dzięki @ETHproductions. Zapisano 1 bajt dzięki @jrich.

Węzeł, 145 142 bajtów

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

To wydaje się trochę długie i prawdopodobnie jest trochę miejsca na grę w golfa. Zauważ, że średnik na końcu jest wymagany; bez tego program zgłasza błąd składniowy, ponieważ forinstrukcja nie ma treści.

Wysyła znacznie ponad 20 linii na sekundę; mała ptaszyna powiedziała mi, że to około 12 tysięcy. Oto jak to wygląda w emulatorze terminali ConEmu na moim komputerze (zarejestrowanym przy 30 fps):

05AB1E , 26 bajtów

Publikuję to jako inną odpowiedź w stosunku do innej odpowiedzi 05AB1E, ponieważ podejście jest inne

.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

Wypróbuj online!

BASH, 99 93 92 91 88 bajtów

z tr+ head+urandom

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

(dzięki za @manatwork)

05AB1E, 30 bajtów

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

Wykorzystuje kodowanie CP-1252 . Wypróbuj online!

Proszę, pomóż mi zagrać w golfa.

C, 182 176 128 126 125 bajtów

Gra w golfa:

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

Nie golfowany:

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

Słyszałem, że można upuścić niektóre standardowe #includepliki, ale nie udało mi się uruchomić kompilatora MingW GCC, który właśnie pobrałem. Nie mogłem też wymyślić, jak to zrobić #define b #includebez zajmowania więcej miejsca niż było to warte. Jestem tylko idiotą, bez nich to działa dobrze.

Java 7, 271 265 207 bajtów

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 bajtów zaoszczędzonych dzięki @ OliverGrégoire . ( Nie zapomnij głosować na jego jeszcze krótszą odpowiedź dotyczącą języka Java 8 ).

Nie golfowany:

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

Wejście: abcde
Wyjście:

WinDbg, 400 391 bajtów

.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 bajtów poprzez uproszczenie matematyki

Zdecydowanie nie wydaje się, że takie jest przeznaczenie WinDbg. ;)

Wprowadzanie odbywa się przez wprowadzenie ciągu ascii w miejscu pamięci i ustawienie tego adresu w pseudorejestru $t0. Na przykład:

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

Używam prng bez względu na zawartość w pamięci, niektóre bajty za ciągiem wejściowym. Wygląda na to, że Chrome.exe wypełnia miejsce w pamięci 0x2000000bajtami o wystarczającej ilości losowo, więc użyłem zrzutu chrome.exe. Nie wiadomo, czy to jednolite, ale wydaje mi się wystarczająco losowe.

Jak to działa:

.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

Uwaga: Niektóre bajty można zagrać w golfa za pomocą jzamiast nich .if, ale to powoduje, że działa on zbyt wolno na moim komputerze, więc nie wyprowadza co najmniej 20 linii na sekundę, więc nie zapisujesz tych bajtów.

Przykładowe dane wyjściowe: http://pastebin.com/H4H74sAx

R, 138 bajtów

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

Odczytuje dane wejściowe ze standardowego wejścia.

Policzyłem około 61 linii na mojej maszynie między każdą dodatkową literą w „haśle”.

Bash, 247 245 212 207 bajtów

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"

Wielkie dzięki Bash za wrażliwość na białe znaki ...

W każdym razie dane wyjściowe podawane są w czasie rzeczywistym na osobnych liniach. Zapisz jako .shskrypt i wywołaj za pomocą:

bash <File Name>.sh <Input>

Na przykład bash Cracking_In_Progress.sh okayertydaje następującą wydajność, rejestrowaną przy 30 klatkach na sekundę:

Haskell (GHC), 202 bajty

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 bajtów bez fantazyjnej akcji powrotu karetki

MATL , 26 bajtów

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

Wypróbuj online!

Poniżej przedstawiono dane wyjściowe kompilatora offline w czasie rzeczywistym. Zwróć uwagę, że animowany GIF został nagrany przy 20 fps, aby zachować mały rozmiar, ale rzeczywista prędkość jest znacznie większa.

Jak to działa

           % 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 bajtów

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

Dane wejściowe ze standardowego wejścia.

Wersja oczy (157 bajtów):

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 bajty

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

Podobne do @ETHproductions (pożyczył niektóre z jego optymalizacji), ale poza tym ma inne podejście. Używa Węzłów Bufferdo obsługi generowania znaków zamiast długich String.fromCharCode, co ma tę dodatkową zaletę, że pozwala nam korzystać mapbez większego nakładu konwersji łańcuchów> tablica>.

Python 3, 167 166 bajtów

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)

Odczytuje dane wejściowe ze standardowego wejścia. Wersja 171 bajtów działa pod Pythonem 2 (zastąpiona inputprzez 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)

Nie golfowany:

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 bajtów

Rozwiązanie

Wymaga ⎕IO←0ustawienia domyślnego w wielu systemach.

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

Pokaz

Dostosowując okno do dwóch linii, uzyskujemy złudzenie transformacji w miejscu:

Wyjaśnienie

Jest to anonimowy ciąg funkcji, który przyjmuje hasło jako właściwy argument.

⊢⊣ zwróć hasło i odrzuć wynik

≢{... }¨ poniższa funkcja, z długością hasła jako lewym argumentem, zastosowana do każdego z nich

 2⊃⎕AIaktualny czas pracy (świeci trzeci element informacji A ccount I nformation )

 1E3+ dodaj sekundę

 t←przypisz to do t

 ⊣ odrzuć to

 ⍵{... }⍣{t≤2⊃⎕AI}⍺stosuj następującą funkcję (z podciągu jako as i długością hasła jako ⍵ ) wielokrotnie, aż czas up osiągnie t

  ⍵⍴95 95 powtórzone tyle razy, ile znaków jest w haśle

  ? losowa liczba całkowita 0 ... 94

  32+dodaj 32 (uzyskując w ten sposób ⍵ losowych liczb całkowitych z zakresu 32 ... 126)

  ⎕UCS przekonwertować na znak Unicode

  ⍺, dodaj aktualnie przetwarzany podciąg

  ⍵↑ wprowadź tylko tyle znaków, ile jest w haśle

  ⎕← wyprowadza to w osobnym wierszu

  ≢ zwraca długość wyprowadzanego ciągu (= długość hasła)

⍳∘≢ 0 ... długość-1

↑¨każdy bierze postacie z

⊂ hasło

Java, 159 bajtów

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

Ten sam algorytm, co odpowiedź Kevina Cruijssena , tylko całkowicie zoptymalizowany dla Java 8.

Nie golfowany:

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 bajtów

Gra w golfa:

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

Nie golfowany:

    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 przechowuje długość wejściową.

StopWatchi Path.GetRandomFileName()są częścią środowiska .NET.

EDYCJA 1: Domniemana Stopwatchdeklaracja.

EDYCJA 2: linicjalizacja połączona z deklaracją.

EDIT3: Dzięki, @Chris.

Scala, 259 254 248 233 232 231 227 225 bajtów

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

Nie golfowany:

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 bajtów

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 bajtów

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

Wypróbuj online!

Po prostu drukuje 20 losowych ciągów oczekujących na 50 std::chrono::millisecondsmiędzy sobą (w ten sposób generując dokładnie 20 linii na sekundę), a następnie przechodzi do następnego kroku „crackowania”.

Idź , 244 bajty

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

Wypróbuj online! (obcina wynik, aby nie wyświetlał wszystkich instancji)

To moja pierwsza odpowiedź Golanga \ o /

(Nakręcony @ 30 fps)

W jaki sposób:

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 bajty

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

Nie golfił

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

(wiem, że film to bzdury)

Tcl , 295 bajtów

Pierwszy golf dla mnie w Tcl. Nie jest to bardzo golfowy język, ponieważ wszystko jest tutaj traktowane jako ciąg znaków, więc białe znaki są zwykle koniecznością ...

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

Nie golfowany:

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 bajtów

Grał w golfa

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)

Nie golfił

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)

Zmiana nazwy System.currentTimeMillispozwoliła zaoszczędzić sporo bajtów!

QBIC , 92 88 bajtów

Złamałem to!

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

Zależy to od funkcji SLEEP QBasica używającej literału kodu $sleep 1|oraz od LEFT$funkcji QBasic, ponieważ nie zaimplementowałem tej funkcji w QBIC ...

Udało się zeskrobać kilka bajtów, podstawiając wszystkie 20cyfry ti ustawiając to na 20. Ponadto usprawniono wywołanie losowe i pętlę FOR.

Wyjaśnienie:

' 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

Wyjście (fragment środkowej części „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