Erinnern Sie sich an die Brute-Force-Programme, die Kennwörter knacken und alle Kombinationen anzeigen, die sie versuchen? Genauer gesagt, an einem Punkt sind die n ersten Zeichen festgelegt (sie wurden erfolgreich erraten), und jedes mögliche Zeichen für die übrigen Zeichen wird getestet. Wahrscheinlich haben Sie einige in Filmen oder in einer Software gesehen, die von Leuten geschrieben wurde, die ausgefallene Oberflächen mögen.
Es tut uns leid, Sie zu enttäuschen, aber wir werden kein Programm zum Knacken von Passwörtern schreiben, nur eines, um die schöne Ausgabe zu reproduzieren.

Herausforderung

Bei einer Zeichenfolge, die druckbare ASCII-Zeichen, aber keine Zeilenumbrüche enthält (ASCII-Code 32 bis 126 oder mit dem regulären ^[ -~]{2,}$Ausdruck übereinstimmend ), wird eine Ausgabe nach folgenden Regeln gedruckt:

• Zur Zeit t=n secondssind die nersten gedruckten Zeichen die nersten Zeichen der Eingabezeichenfolge.
• Nach den nfesten Zeichen sollten Sie eine Zeichenfolge anhängen, die aus einem zufälligen Zeichen besteht (einheitlich pseudozufällig ausgewählt aus dem Unicode-Bereich   bis ~(Code 32 bis 126)), um eine Zeichenfolge mit der Länge der anfänglichen Zeichenfolge zu bilden.
• Sie sollten mindestens (dazu später mehr) 20 Zeilen pro Sekunde ausgeben : Jedes von ihnen hat die gleichen nersten Zeichen, aber ein anderes zufälliges Ende.

Es ist wahrscheinlich noch nicht ganz klar, was Sie tun sollen. Lassen Sie uns ein Beispiel durchgehen:

Beispiel

Ich drucke nur 5 verschiedene Zeilen pro Sekunde anstatt der 20 Zeilen, um die Lesbarkeit zu verbessern.

Betrachten Sie die Eingabe abcde.
Während der ersten Sekunde kann eine gültige Ausgabe so etwas wie (völlig zufällig) sein:

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

Dann ist t=1das erste Zeichen jeder folgenden Zeichenfolge a(das erste Zeichen der Eingabe):

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

Nun sind t=2die ersten beiden Zeichen ab:

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

Nun sind t=3die ersten drei Zeichen abc:

abcvW
abc3G
abc(g
abc{@
abc@4

Nun sind t=4die ersten vier Zeichen abcd:

abcdD
abcdv
abcdj
abcd$
abcd6

Schließlich t=5drucken wir die Eingabe (nur einmal):

abcde

Ein paar Präzisionen

• Sie sollten sich nicht zu sehr mit der Genauigkeit Ihrer Sprache auf die Sekunden konzentrieren (dh, wenn Ihr Algorithmus korrekt ist, Ihrem System / Ihrer Sprache jedoch die Genauigkeit fehlt, ist dies in Ordnung).
• Die erste Sekunde kann kürzer als eine Sekunde sein (Das heißt, wenn Sie Ihr Programm während einer Sekunde starten, kann die erste Sekunde nur die verbleibende Zeit bis zum Ende der aktuellen Sekunde sein). Oder anders ausgedrückt: Sie müssen nicht auf den Beginn einer neuen Sekunde warten, um mit dem Drucken der Ausgaben zu beginnen.
• Mindestens 20 Zeilen pro Sekunde : Der natürlichere Weg wäre eine Endlosschleife mit einem besonderen Verhalten pro Sekunde (oder einer Zeitüberschreitung oder was auch immer), so dass wahrscheinlich ein paar tausend Zeilen pro Sekunde entstehen (und das ist vollkommen in Ordnung!). ). Wenn Sie jedoch eine andere Idee haben, können Sie sie verwenden, solange Sie mindestens 20 Zeilen pro Sekunde drucken.
• Die Eingabe wird immer länger als 2 Zeichen sein.
• Sie können davon ausgehen, dass die Eingabe nicht länger als 30 Zeichen ist, wenn dies hilfreich ist. (Aber wenn es für längere funktioniert, ist es das Beste)
• Das Eingabeformat sollte die natürlichste Darstellung einer Zeichenfolge in Ihrer Sprache sein.
• Sie dürfen eine abschließende Newline drucken.

Codebeispiel

Wenn Sie immer noch nicht genau wissen, was Sie zu tun haben, können Sie den folgenden Code in einem Linux-Terminal ausführen, um zu sehen:

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

Gewinnkriterium

Das ist Code-Golf , also gewinnt der kürzeste Code in Byte!

Pyth - 27 24 Bytes

Das sieht eigentlich ziemlich cool aus: D

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

Probieren Sie es hier online aus (natürlich nicht in Echtzeit, aber wenn Sie mit einer ruhigen Hand nach unten scrollen).

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>

Bearbeiten: 2 Bytes dank @ETHproductions gespeichert. 1 Byte dank @jrich gespeichert.

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

Dies scheint ein bisschen lang zu sein und es gibt wahrscheinlich ein wenig Raum zum Golfen. Beachten Sie, dass das Semikolon am Ende erforderlich ist. Ohne diesen Befehl gibt das Programm einen Syntaxfehler aus, da die forAnweisung keinen Text enthält.

Gibt weit mehr als 20 Zeilen pro Sekunde aus; Ein kleiner Piepmatz sagte mir, dass es ungefähr 12 Tausend sind. So sieht es im ConEmu-Terminalemulator auf meinem Computer aus (aufgenommen mit 30 fps):

05AB1E , 26 Bytes

Ich poste dies als eine andere Antwort in Bezug auf die andere 05AB1E-Antwort, da der Ansatz anders ist

.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

Probieren Sie es online!

BASH, 99 93 92 91 88 Bytes

mit tr+ head+urandom

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

(Danke an @manatwork)

05AB1E, 30 Bytes

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

Verwendet die CP-1252- Codierung. Probieren Sie es online!

Bitte helfen Sie mir beim Golfspielen.

C 182 176 128 126 125 Byte

Golf gespielt:

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
}

Ich habe gehört, dass es möglich ist, einige Standards #includezu löschen, aber ich konnte es nicht auf dem MingW GCC-Compiler zum Laufen bringen, den ich gerade heruntergeladen habe. Konnte auch nicht herausfinden, wie es geht, #define b #includeohne mehr Platz zu verbrauchen, als es wert war. Ich bin nur ein Idiot, es funktioniert gut ohne sie.

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 gespart dank @ OliverGrégoire . ( Vergessen Sie nicht, seine noch kürzere Java 8-Antwort zu verbessern. )

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

Eingabe: abcde
Ausgabe:

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 durch Vereinfachung der Mathematik

Dies scheint definitiv nicht die Aufgabe von WinDbg zu sein. ;)

Die Eingabe erfolgt durch Eingeben einer ASCII-Zeichenfolge an einem Speicherort und Setzen dieser Adresse in das Pseudoregister $t0. Z.B:

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

Das von mir verwendete prng ist der Inhalt im Speicher, einige Bytes nach der Eingabezeichenfolge. Chrome.exe scheint den Speicherplatz danach 0x2000000mit zufällig aussehenden Bytes zu füllen, sodass ich einen Speicherauszug von chrome.exe verwendet habe. Unbekannt, ob dies einheitlich ist, aber für mich eher zufällig aussieht.

Wie es funktioniert:

.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

Hinweis: Einige Bytes könnten durch die Verwendung von janstelle von golfen werden .if, aber das führt dazu, dass es auf meinem Computer zu langsam läuft, sodass nicht mindestens 20 Zeilen pro Sekunde ausgegeben werden und diese Bytes nicht gespeichert werden.

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

Liest die Eingabe von stdin.

Zählte ungefähr 61 Zeilen auf meinem Computer zwischen jedem zusätzlichen Buchstaben im "Passwort".

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"

Vielen Dank, Bash, dass du so sensibel für Whitespace bist ...

Die Ausgabe erfolgt in Echtzeit auf separaten Zeilen. Als .shSkript speichern und aufrufen mit:

bash <File Name>.sh <Input>

Das bash Cracking_In_Progress.sh okayertyErgebnis ist beispielsweise die folgende Ausgabe, die mit 30 Bildern pro Sekunde aufgezeichnet wurde:

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 ohne ausgefallene Wagenrücklaufaktion

MATL , 26 Bytes

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

Probieren Sie es online!

Unten sehen Sie die Echtzeitausgabe des Offline-Compilers. Beachten Sie, dass das animierte GIF mit 20 fps aufgenommen wurde, um seine Größe klein zu halten, die tatsächliche Geschwindigkeit jedoch viel höher ist.

Wie es funktioniert

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

Eingabe von stdin.

Augenversion (157 Bytes):

import time,random
p,i,x=print,input(),0;l=len(i)
while x<l:x=int(time.clock());p(i[:x]+"".join(chr(random.randint(32,126))for _ in"a"*(l-x)),end="\r")
p(i)

Node.js, 134 Bytes

for(s=[...process.argv[2]],n=new(d=Date);s[m=(new d-n)/1e3|0]+console.log(s.map((a,i)=>i<m?a:Buffer([Math.random()*95+32])).join``););

Ähnlich wie @ETHproductions (einige seiner Optimierungen entlehnt), aber ansonsten einen anderen Ansatz. Verwendet Node's Buffer, um die Zeichengenerierung anstatt der langwierigen zu handhaben String.fromCharCode, was den Nebeneffekt hat, dass wir mapohne großen Aufwand für die Konvertierung von Zeichenfolgen-> Array-> Zeichenfolgen arbeiten müssen.

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)

Liest die Eingabe von stdin. Eine 171-Byte-Version läuft unter Python 2 (ersetzt inputdurch raw_input):

import time,random
t=time.time
p,s=raw_input(),t()
while t()-s<len(p):print(p[:int(t()-s)]+''.join(chr(random.randint(32,126))for _ in range(len(p)-int(t()-s))))
print(p)

Ungolfed:

import random
import time

p = input()
start = time.time()
while time.time() - start < len(p): 
    print(
        p[:int(time.time() - start)] + 
        ''.join(chr(random.randint(32, 126)) for _ in range(len(p) - int(time.time()-start)))
    )
print(p)

Dyalog APL , 59 58 Bytes

Lösung

Benötigt, ⎕IO←0was auf vielen Systemen Standard ist.

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

Anzeige

Wenn Sie das Fenster auf zwei Zeilen einstellen, entsteht die Illusion einer In-Place-Transformation:

Erläuterung

Dies ist ein anonymer Funktionszug, der das Passwort als richtiges Argument verwendet.

⊢⊣ Gib das Passwort zurück und verwerfe das Ergebnis von

≢{... }¨ die folgende Funktion mit der Länge des Passworts als linkem Argument, angewendet auf jedes von

 2⊃⎕AIaktuelle Betriebszeit (Lit. drittes Element A ccount I nformations)

 1E3+ füge eine Sekunde hinzu

 t←ordne das t zu

 ⊣ entlassen Sie das

 ⍵{... }⍣{t≤2⊃⎕AI}⍺wenden Sie die folgende Funktion (mit Unterzeichenfolge als ⍺ und Kennwortlänge als ⍵ ) so oft an, bis die Betriebszeit t erreicht

  ⍵⍴95 95 Wird so oft wiederholt, wie das Kennwort Zeichen enthält

  ? zufällige ganze Zahl 0 ... 94

  32+addiere 32 (was ⍵ zufällige ganze Zahlen im Bereich 32 ... 126 ergibt )

  ⎕UCS in Unicode-Zeichen konvertieren

  ⍺, Stellen Sie den aktuell verarbeiteten Teilstring voran

  ⍵↑ Nehmen Sie nur so viele Zeichen, wie im Passwort enthalten sind

  ⎕← Gib das in einer separaten Zeile aus

  ≢ Liefert die Länge des ausgegebenen Strings (= die Länge des Passworts)

⍳∘≢ 0 ... Länge-1

↑¨jeder nimmt Zeichen aus

⊂ das Passwort

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

Gleicher Algorithmus wie die Antwort von Kevin Cruijssen , nur für Java 8 optimiert.

Ungolfed:

public class Tmp {

  interface X {

    void f(String s) throws Exception;
  }
  static X f = s -> {
    for (int i = 0, j, l = s.length(); i <= l * 20; i++) {
      String r = s.substring(0, j = i / 20);
      Thread.sleep(48);
      for (; j++ < l; r += (char) (32 + Math.random() * 94));
      System.out.println(r);
    }
  };

  public static void main(String[] args) throws Exception {
    f.f("abcde");
  }
}

C # 203 197 195 190 Bytes

Golf gespielt:

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 Speichert die eingegebene Länge.

StopWatchund Path.GetRandomFileName()sind Teile von .NET Framework.

EDIT1: Implizite StopwatchDeklaration.

EDIT2: lInitialisierung mit Deklaration zusammengeführt.

EDIT3: Danke, @Chris.

Scala, 259 254 248 233 232 231 227 225 Bytes

import scala.concurrent.duration._;(b:String)=>{val d=b.length.seconds.fromNow;while(d.hasTimeLeft)println(b.zipWithIndex.map{case(f,g)=>if(g<b.length-d.timeLeft.toSeconds-1)f else(32+math.random*94)toChar}mkString);print(b)}

Ungolfed:

import scala.concurrent.duration._;

(b:String) => {
    val d = b.length.seconds.fromNow;
    while(d.hasTimeLeft)
        println(
            b.zipWithIndex.map{
                case(f,g) => 
                    if(g<b.length-d.timeLeft.toSeconds-1)
                        f 
                    else
                        (32+math.random*94)toChar}
            mkString
        );

    print(b)
}

ForceLang , 322 309 Bytes

def s set
s g goto
s W io.writeln
s k io.readln()
s T timer.new()
def a T.poll()
label 1
s P math.floor a.mult 1e-6
if P=k.len
 W k
 exit()
s j 0
s t ""
if P=0
g 4
label 3
s v k.charAt j
s t t+v
s j 1+j
if j-P
g 3
label 4
if j=k.len
 W t
 g 1
s r 94.mult random.rand()
s v string.char 32+r
s t t+v
s j 1+j
g 4

C ++ (GCC) , 280 278 Bytes

#include<iostream>
#include<chrono>
#include<cstdlib>
#include<thread>
int i,n,t,q;void f(std::string s){for(t=s.size(),n=0;n<=t;n++)for(q=n<t?20:1;q--;std::this_thread::sleep_for(std::chrono::milliseconds(50)))for(std::cout<<"\n"<<s.substr(0,i=n);i++<t;)putchar(32+rand()%84);}

Probieren Sie es online!

Es werden nur 20 zufällige Zeichenfolgen gedruckt, die auf 50 std::chrono::millisecondsZeilen warten (wodurch genau 20 Zeilen pro Sekunde ausgegeben werden), und dann wird mit dem nächsten "Cracking" -Schritt fortgefahren.

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

Probieren Sie es online! (Schneidet das Ergebnis ab, damit nicht jede Instanz angezeigt wird.)

Dies ist meine erste Golang-Antwort \ o /

(Gefilmt mit 30 Bildern pro Sekunde)

Wie:

func a(s string) {                      //function a
Seed(Now().Unix())                      //Create a seed for the pRNG
for i := 0; i < len(s); i++ {           //set helper var i (this is the number of characters we'll keep)
t := Now().Truncate(Second).Add(Second) //set helper var t = 1 second from now
for Now().Before(t) {                   //while inside that 1 second window
q := []rune(s)                          //put each character in a rune slice and assign that to q
for p := len(q) - 1; p >= i; p-- {      //loops through the rune slice
q[p] = rune(32 + Intn(95))              //replace the character in position p with a random code point in [32,126]
}
Println(string(q))                      //print the rune slice as a string
}
}
Print(s)                                //finally, print the original string
}

PHP, 222 Bytes

$a=$argv[1];$c=range(32,126);$t=time();$s=$t;$e=$t+strlen($a);while(time()<=$e){$l=time();$p=$l-$s;$x=substr($a,0,$p);$k=$e-$l;$r='';for($i=$k;$i>0;$i--)$r.=chr($c[rand(0,94)]);$o=$x.$r;echo"$o\n";if($o==$a&&$l==$e)break;}

Ungolfed

<?php
$input = $argv[1];
$chars = range(32, 126); // count() is 95

$startTime = time();
$endTime = time() + strlen($input);

while (time() <= $endTime) {
    $plaintextAmountToPrint = time() - $startTime;

    $plain = substr($input, 0, $plaintextAmountToPrint);

    $cryptAmountToPrint = $endTime - time();

    $crypt = '';

    for ($i = $cryptAmountToPrint; $i > 0; $i--)
        $crypt .= chr($chars[rand(0, 94)]);

    $output = $plain . $crypt;

    echo $output . "\n";

    if ($output == $input && time() == $endTime)
        break;
}

(Ich weiß, das Video ist Mist)

Tcl , 295 Bytes

Erster Golf für mich in Tcl. Keine sehr golferische Sprache, da hier alles wie eine Saite behandelt wird und Leerzeichen normalerweise ein Muss sind ...

set l [string length $argv];set s [clock seconds];set r -1;while {$r<$l-1} {puts -nonewline [string range $argv 0 $r];set k $l;while {[set k [expr $k-1]]>$r} {puts -nonewline [format %c [expr int(rand()*95+32)]]};puts "";if {[expr [clock seconds]-$s]>[expr $r+1]} {set r [expr $r+1]}};puts $argv

Ungolfed:

set l [string length $argv]
set s [clock seconds]
set r -1
while {$r < $l-1} {                                      # loop on time
  puts -nonewline [string range $argv 0 $r]
  set k $l
  while {[set k [expr $k-1]] > $r} {                     # loop on "unfound" chars
    puts -nonewline [format %c [expr int(rand()*95+32)]]
  }
  puts ""
  if {[expr [clock seconds]-$s] > [expr $r+1]} {         # advance time
    set r [expr $r+1]
  }
}
puts $argv

Kotlin, 188 Bytes

Golf gespielt

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)

Das Umbenennen System.currentTimeMillishat einige Bytes gespart!

QBIC , 92 88 Bytes

Ich habe es geknackt!

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

Dies beruht auf der SLEEP-Funktion von QBasic mit dem Codeliteral $sleep 1|und auf der LEFT$Funktion von QBasic, da ich diese Funktion noch nicht in QBIC implementiert habe ...

Es ist gelungen, ein paar Bytes zu kratzen, indem alle für 20's ersetzt tund auf 20 gesetzt wurden. Außerdem wurde ein Aufruf von random und eine FOR-Schleife optimiert.

Erläuterung:

' 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 (ein Stück aus dem Mittelteil von '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