시도하는 모든 조합을 보여주는 암호를 해독하는 무차별 프로그램을 기억하십니까? 보다 정확하게는, 한 시점에서, n 개의 첫 번째 문자가 고정되고 (성공적으로 추측 됨) 나머지 문자에 대해 가능한 모든 문자가 테스트됩니다. 영화 나 멋진 인터페이스를 좋아하는 사람들이 작성한 일부 소프트웨어를 보셨을 것입니다.
실망스럽게도 죄송하지만 비밀번호를 해독하는 프로그램은 작성하지 않으며 멋진 출력을 재현하는 프로그램 만 작성합니다.

도전

인쇄 가능한 ASCII 문자를 포함하지만 줄 바꿈이없는 문자열 (아스키 코드 32-126 또는 정규식과 일치 ^[ -~]{2,}$)이있는 경우 다음 규칙에 따라 출력을 인쇄하십시오.

• 시간 t=n seconds에 n인쇄 된 n첫 문자는 입력 문자열 의 첫 문자입니다.
• 애프터 n고정 자하면 (유니 코드 범위에서 균일 한 의사 - 무작위로 선택된 캐릭터 형성된 임의의 문자를 추가한다   으로 ~초기 하나의 길이 스트링을 형성하기 위해 (코드 126-32)).
• 적어도 매 20 줄 이상을 출력해야합니다 . 모든 n문자는 첫 번째 문자는 같지만 임의의 끝은 다릅니다.

아마 당신이해야 할 일이 아직 명확하지 않을 수도 있으므로 예제를 살펴 보겠습니다.

예

더 읽기 쉽게하기 위해 최소 20 개 대신 매초마다 5 개의 다른 행만 인쇄합니다.

입력을 고려하십시오 abcde.
첫 번째 초 동안 유효한 출력은 다음과 같습니다 (완전히 임의 임).

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

그런 다음 t=1모든 다음 문자열 a의 첫 번째 문자는 (입력의 첫 번째 문자)입니다.

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

이제 t=2처음 두 문자는 다음과 ab같습니다.

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

이제 t=3첫 세 문자는 다음과 abc같습니다.

abcvW
abc3G
abc(g
abc{@
abc@4

이제 t=4첫 네 문자는 다음과 abcd같습니다.

abcdD
abcdv
abcdj
abcd$
abcd6

마지막으로 t=5입력을 한 번만 인쇄합니다.

abcde

몇 가지 정밀도

• 언어 정확도를 초 단위로 너무 신경 쓰지 않아야합니다 (즉, 알고리즘이 정확하지만 시스템 / 언어의 정밀도가 부족하면 괜찮습니다).
• 첫 번째 초는 1 초보다 짧을 수 있습니다 (즉, 1 초 동안 프로그램을 시작하면 첫 번째 초는 현재 초가 끝날 때까지 남은 시간 일 수 있음). 다르게 말하면, 출력을 인쇄하기 위해 새로운 초가 시작될 때까지 기다릴 필요가 없습니다.
• 초당 20 줄 이상 :보다 자연스러운 방법은 초당 1 회 (또는 시간 초과 등) 특별한 동작을 갖는 무한 루프이므로 초당 수천 줄이 될 것입니다. ). 그러나 다른 아이디어가 있다면 초당 최소 20 줄을 인쇄하는 한 자유롭게 사용하십시오.
• 입력은 항상 2 자 이상입니다.
• 도움이 되더라도 입력 길이가 30자를 넘지 않을 것이라고 생각할 수 있습니다. (그러나 그것이 더 긴 것들을 위해 작동한다면, 최선입니다)
• 입력 형식은 사용자 언어에서 문자열을 가장 자연스럽게 표현해야합니다.
• 후행 줄 바꿈을 인쇄 할 수 있습니다.

코드 예

여전히 정확히 무엇을해야하는지 이해하지 못하는 경우 Linux 터미널에서 다음 코드를 실행하여 확인할 수 있습니다.

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

승리 기준

이것은 code-golf 이므로 바이트 단위의 가장 짧은 코드가 승리합니다!

Pyth- 27 24 바이트

이것은 실제로 꽤 멋져 보입니다 : D

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

여기에서 온라인으로 시도하십시오 (실시간은 아니지만 안정적인 손으로 스크롤하면).

HTML / 자바 스크립트, 170 168 167 바이트

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>

편집 : @ETHproductions 덕분에 2 바이트가 절약되었습니다. @jrich 덕분에 1 바이트를 절약했습니다.

노드, 145142 바이트

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

이것은 조금 길어 보이고 골프를위한 여지가 거의 없을 것입니다. 끝에 세미콜론이 필요합니다. 그렇지 않으면 for명령문에 본문이 없으므로 프로그램에서 구문 오류가 발생합니다 .

초당 20 라인 이상 출력합니다. 작은 버디가 나에게 약 12 ​​만 마리라고 말했습니다. 다음은 내 컴퓨터의 ConEmu 터미널 에뮬레이터에서 보이는 방법입니다 (30fps로 기록됨).

05AB1E , 26 바이트

접근법이 다르기 때문에 다른 05AB1E 답변과 관련하여 다른 답변으로 게시했습니다.

.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

온라인으로 사용해보십시오!

BASH, 99 93 92 91 88 바이트

와 tr+ head+urandom

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

(@xmanatwork)

05AB1E, 30 바이트

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

CP-1252 인코딩을 사용합니다 . 온라인으로 사용해보십시오!

이 골프를 도와주세요.

C, 182 176 128 126 125 바이트

골프 :

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

언 골프 드 :

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

표준을 떨어 뜨릴 #include수 있다고 들었지만 방금 다운로드 한 MingW GCC 컴파일러에서 작동하도록 할 수 없었습니다. 또한 #define b #include가치보다 더 많은 공간을 사용하지 않으면 서 방법을 알 수 없었 습니다. 나는 바보 일 뿐이다. 그들 없이는 잘 작동한다.

자바 7, 271 265 207 바이트

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

@ OliverGrégoire 덕분에 -58 바이트가 절약 되었습니다 . ( 더 짧은 Java 8 답변을 찬성하는 것을 잊지 마십시오. )

언 골프 드 :

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

입력 : abcde
출력 :

WinDbg, 400 391 바이트

.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 바이트

이것은 WinDbg가 의도 한 것 같지는 않습니다. ;)

메모리 위치에 ASCII 문자열을 입력하고 해당 주소를 pseudo-register로 설정하면 입력이 이루어집니다 $t0. 예 :

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

내가 사용하는 prng은 메모리의 내용과 관계없이 입력 문자열을 약간 넘는 바이트입니다. Chrome.exe 0x2000000는 무작위로 보이는 충분한 바이트로 메모리 공간을 채우는 것처럼 보이 므로 chrome.exe 덤프를 사용했습니다. 이것이 균일하지만 알려지지 않은 것처럼 보이면 알 수 없습니다.

작동 방식 :

.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

참고 :의 j대신을 사용하여 일부 바이트를 골퍼 링 할 수 .if있지만 내 컴퓨터에서 너무 느리게 실행되므로 초당 최소 20 줄이 출력되지 않으므로 해당 바이트를 저장하지 않습니다.

샘플 출력 : http://pastebin.com/H4H74sAx

R, 138 바이트

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

stdin에서 입력을 읽습니다.

"비밀번호"의 각 추가 문자 사이에 내 컴퓨터에서 약 61 줄을 세었습니다.

배시, 247 245 212 207 바이트

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"

공백에 민감하므로 Bash에게 감사드립니다.

어쨌든 출력은 별도의 라인에 실시간으로 제공됩니다. .sh스크립트 로 저장 하고 다음을 호출 하십시오 .

bash <File Name>.sh <Input>

예를 들어, bash Cracking_In_Progress.sh okayerty초당 30 프레임으로 기록 된 다음과 같은 출력이 발생합니다.

하스켈 (GHC), 202 바이트

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 바이트

MATL , 26 바이트

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

온라인으로 사용해보십시오!

아래는 오프라인 컴파일러의 실시간 출력입니다. 애니메이션 GIF는 크기를 작게 유지하기 위해 20fps로 기록되었지만 실제 속도는 훨씬 큽니다.

작동 원리

           % 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 바이트

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

stdin에서 입력

눈 버전 (157 바이트) :

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 바이트

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

@ETHproductions와 유사하지만 (일부 최적화를 차용 한) 다른 방법으로 접근합니다. Buffer길이가 아닌 문자 생성을 처리하기 위해 노드를 사용 String.fromCharCode하므로 map많은 문자열-> 배열-> 문자열 변환 오버 헤드없이 사용할 수있는 부작용이 있습니다 .

파이썬 3, 167166 바이트

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)

stdin에서 입력을 읽습니다. 171 바이트 버전은 파이썬이 (대체에서 실행 input으로 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)

언 골프 드 :

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 바이트

해결책

⎕IO←0많은 시스템에서 기본값이 필요합니다 .

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

디스플레이

창을 두 줄로 조정하면 내부 변형의 환상을 얻습니다.

설명

이것은 암호를 올바른 인수로 취하는 익명의 기능 기차입니다.

⊢⊣ 암호를 반환하고 결과를 무시하십시오

≢{... }¨ 왼쪽 인수로 암호 길이를 사용하여 아래의 함수 각각에 적용

 2⊃⎕AI현재까지 시간 (점등의 번째 요소 ccount I가 nformation)

 1E3+ 두 번째를 추가

 t←그것을 t에 할당

 ⊣ 무시

 ⍵{... 가동 시간이 t에 도달 할 때까지 }⍣{t≤2⊃⎕AI}⍺다음 기능 (하위 문자열을 ⍺로 , 암호 길이를 ⍵으로 )을 반복해서 적용하십시오

  ⍵⍴95 암호에 문자가있는 횟수만큼 95 회 반복

  ? 임의의 정수 0 ... 94

  32+32 더하기 (따라서 32 ... 126 범위의 ⍵ 임의의 정수 를 생성 )

  ⎕UCS 유니 코드 문자로 변환

  ⍺, 현재 처리 된 부분 문자열 앞에 추가

  ⍵↑ 암호에있는만큼의 문자 만 사용하십시오

  ⎕← 별도의 줄에 출력

  ≢ 출력 된 문자열의 길이를 리턴합니다 (= 비밀번호의 길이).

⍳∘≢ 0 ... 길이 -1

↑¨각각에서 문자를 복용

⊂ 비밀번호

자바, 159 바이트

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

Kevin Cruijssen의 답변 과 동일한 알고리즘으로 Java 8에만 완전히 최적화되었습니다.

언 골프 드 :

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 바이트

골프 :

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

언 골프 드 :

    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 입력 길이를 저장합니다.

StopWatch및 Path.GetRandomFileName().NET 프레임 워크의 일부입니다.

EDIT1 : 암시 적 Stopwatch선언.

EDIT2 : l초기화가 선언과 병합되었습니다.

EDIT3 : 감사합니다, @Chris.

스칼라 259 254 248 233 232 231 227 225 바이트

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

언 골프 드 :

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 바이트

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) 바이트

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

온라인으로 사용해보십시오!

std::chrono::milliseconds서로간에 50을 기다리는 20 개의 임의 문자열을 인쇄 하므로 (초당 정확히 20 줄 출력) 다음 "크래킹"단계로 진행됩니다.

이동 , 244 바이트를

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

온라인으로 사용해보십시오! (모든 인스턴스를 표시하지 않도록 결과를 자릅니다)

이것이 나의 첫 골랑 답변입니다. \ o /

(30fps에서 촬영)

어떻게:

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 바이트

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

언 골프

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

(나는 비디오가 쓰레기라는 것을 안다)

Tcl , 295 바이트

Tcl에서 처음으로 나를 위해 골프. 모든 것이 여기에서 문자열로 취급되므로 공백은 일반적으로 필수이기 때문에 매우 골프 가능한 언어는 아닙니다.

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

언 골프 드 :

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

코 틀린, 188 바이트

골프

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)

언 골프

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)

이름 바꾸기 System.currentTimeMillis 꽤 많은 바이트가 절약되었습니다!

QBIC , 92 88 바이트

나는 그것을 깨뜨렸다!

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

이것은 코드 리터럴을 사용하는 QBasic의 SLEEP 함수에 의존합니다. $sleep 1| 와 LEFT$QBIC에서 해당 함수를 아직 구현하지 않았기 때문에 QBasic의 함수 에 ...

모든 것을 대체하여 몇 바이트를 긁어 관리 20 를위한 '들 t과도 20에 그 설정, 루프에 대한 무작위로 전화 발신을 간소화.

설명:

' 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

출력 ( '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