क्रैकिंग प्रगति पर है

Question

पासवर्ड को क्रैक करने के लिए उन ब्रूट-फोर्स प्रोग्राम को याद रखें जो प्रत्येक संयोजन को दिखा रहे हैं जो वे कोशिश कर रहे हैं? अधिक सटीक रूप से, एक बिंदु पर, एन पहले अक्षर तय किए गए हैं (उन्हें सफलतापूर्वक अनुमान लगाया गया है), और शेष लोगों के लिए हर संभव चरित्र का परीक्षण किया जा रहा है। आपने शायद कुछ फिल्मों में, या लोगों द्वारा लिखे गए कुछ सॉफ़्टवेयर में देखा है जो कि फैंसी इंटरफेस पसंद करते हैं।
निराशा के लिए खेद है, लेकिन हम पासवर्ड क्रैक करने के लिए एक प्रोग्राम नहीं लिखेंगे, केवल एक अच्छा आउटपुट पुन: पेश करने के लिए।

चुनौती

एक स्ट्रिंग को प्रिंट करने योग्य एससीआई वर्णों को देखते हुए लेकिन कोई भी नयालाइन (एससीआई कोड 32 से 126 या रेगेक्स से मेल नहीं खाता ^[ -~]{2,}$), इस नियम का पालन करते हुए एक आउटपुट प्रिंट करें:

• समय पर t=n seconds, nमुद्रित किए गए nपहले वर्ण इनपुट स्ट्रिंग के पहले वर्ण हैं।
• nनिश्चित वर्णों के बाद , आपको प्रारंभिक एक की लंबाई बनाने के लिए एक स्ट्रिंग का गठन यादृच्छिक चरित्र (यूनिकोड रेंज   से ~(कोड 32 से 126)) के लिए समान रूप से छद्म यादृच्छिक रूप से चुना जाना चाहिए ।
• आपको हर सेकंड कम से कम (उस पर बाद में) 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

कुछ पूर्वाग्रह

• आपको सेकंड के प्रति अपनी भाषा की सटीकता के साथ बहुत परेशान नहीं करना चाहिए (यानी यदि आपका एल्गोरिथ्म सही है लेकिन आपके सिस्टम / भाषा में सटीकता की कमी है तो यह ठीक है)।
• पहला सेकंड एक सेकंड से छोटा हो सकता है (यानी, यदि आप एक सेकंड के दौरान प्रोग्राम लॉन्च करते हैं, तो दूसरा सेकंड वर्तमान समय के अंत तक केवल शेष समय हो सकता है)। या अलग तरीके से कहें, तो आपको आउटपुट प्रिंट करने के लिए नए सेकंड के शुरू होने का इंतजार नहीं करना होगा।
• कम से कम 20 लाइनें प्रति सेकंड : अधिक प्राकृतिक तरीका एक विशेष लूप के साथ एक अनन्त लूप होगा जो हर सेकंड (या एक टाइमआउट, या जो भी हो) होगा, जिसके परिणामस्वरूप शायद प्रति सेकंड कुछ हजार लाइनें होंगी (और यह पूरी तरह से ठीक है! )। लेकिन अगर आपके पास एक और विचार है, तो इसका उपयोग करने के लिए स्वतंत्र महसूस करें जब तक कि आप प्रति सेकंड कम से कम 20 लाइनों को प्रिंट नहीं करते।
• इनपुट हमेशा 2 वर्णों से अधिक लंबा होगा।
• आप विचार कर सकते हैं कि यदि इनपुट मदद करता है तो इनपुट 30 वर्णों से अधिक लंबा नहीं होगा। (लेकिन अगर यह लंबे लोगों के लिए काम करता है, तो यह सबसे अच्छा है)
• इनपुट प्रारूप आपकी भाषा में एक स्ट्रिंग का सबसे प्राकृतिक प्रतिनिधित्व होना चाहिए।
• आपको एक अनुगामी न्यूलाइन प्रिंट करने की अनुमति है।

कोड उदाहरण

यदि आपको अभी भी ठीक से समझ नहीं आ रहा है कि आपको क्या करना है, तो आप एक लिनक्स टर्मिनल में निम्नलिखित कोड देख सकते हैं:

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

कसौटी जीतना

यह कोड-गोल्फ है , बाइट जीत में सबसे छोटा कोड है!

---

लैकोनी और Flp.Tkc के लिए धन्यवाद उनके सुझाव और सैंडबॉक्स में सुधार के लिए।

Comments

जैसा फिल्म से इस दृश्य युद्ध खेल ?

— जुन्गवान मिन

क्या आउटपुट की पंक्तियों को अलग करना अनिवार्य है \r(उन सभी को एनीमेशन की तरह एक-दूसरे को परदे पर बदलना), या \nस्वीकार्य है?

@ ais523 \nपूरी तरह से स्वीकार्य है। इसके साथ संस्करण \rसिर्फ यहाँ है क्योंकि यह बेहतर दिखता है, लेकिन आपको उन लोगों की आवश्यकता नहीं है \r।

— दादा

यदि रैंडम जनरेशन पासवर्ड को क्रैक करने के लिए होता है तो क्या उस बिंदु पर रुकना ठीक है?

— जोनाथन एलन

क्या आपको नियमों में शामिल नहीं होना चाहिए कि यादृच्छिक वर्ण उस स्थान पर वास्तविक चरित्र नहीं होना चाहिए ? अन्यथा बेतरतीब तार दिए गए पासवर्ड से मेल खा सकते हैं, लेकिन खोज जारी है, कौन सी फिल्म शौकीनों के लिए एक गड़बड़ होगी।

— टॉम

Answer 1

पायथ - 27 24 बाइट्स

यह वास्तव में बहुत अच्छा लग रहा है: डी

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

इसे ऑनलाइन यहाँ आज़माएँ (स्पष्ट रूप से वास्तविक समय में नहीं, लेकिन यदि आप इसे स्थिर हाथ से स्क्रॉल करते हैं)।

Answer 2

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>

संपादित करें: 2 बाइट्स @ETHproductions की बदौलत सहेजे गए। @Jrich के लिए 1 बाइट का धन्यवाद सहेजा गया।

Comments

यह परीक्षण नहीं किया गया है, लेकिन मेरा मानना ​​है कि setIntervalएक स्ट्रिंग को स्पष्ट रूप से स्वीकार किया जाएगा, जो संभवतः एक बाइट को बचा सकता है? setInterval('o.textContent...',d=50)बचाता है _=>और उद्धरणों की एक जोड़ी जोड़ता है

— jrich

@jrich यह काम कर रहा था, क्योंकि मैं अपनी बाइट गिनती अपडेट करना भूल गया था!

— नील

Answer 3

नोड, 145 142 बाइट्स

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 टर्मिनल एमुलेटर में कैसे दिखता है (30 एफपीएस पर रिकॉर्ड किया गया):

Answer 4

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

इसे ऑनलाइन आज़माएं!

Comments

अच्छा जवाब, मेरी तरफ से +1! नोट: यह इन दिनों नए बिलिन के साथ 22 बाइट्स हो सकता है : के बजाय ; (जहां लिस्ट के रूप में प्रीपेंड है) (जहां लिस्ट में लिपटे हैं, और प्रीपेंड हैं); (जहां 26 है अगर कोई दूसरा इनपुट नहीं दिया गया है) के बजाय (जो कि 10 धक्का है, और डबल); इसके बजाय (जहां एक ही समय में सभी छोरों, यदि-और बयान, आदि बंद हो जाते हैं)η.põššõ¸ì¸ì₂₂T·]}}]

— केविन क्रूज़सेन

Answer 5

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

(thx। @manatwork पर)

Comments

[ "$n" = ${#1} ]→ ((n==${#1})); ${1:0:$n}→${1::n}

— मैनेटवर्क

@manatwork: वाह!

— Ipor Sircer

1 और: इनपुट पुनर्निर्देशन के सामने की जगह की <जरूरत नहीं है।

— 11

@manatwork ((n==${#1}))->((${#1}-n))

— इरपर सेसर

या तो इसलिए कि आपने तर्क को उलट दिया या इसलिए कि मैंने अपना पिछला परीक्षण धमाकेदार किया, लेकिन ${1::n=SECONDS}अब काम करने लगता है।

— मैनटवर्क

Answer 6

05AB1E, 30 बाइट्स

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

CP-1252 एन्कोडिंग का उपयोग करता है । इसे ऑनलाइन आज़माएं!

कृपया मुझे यह नीचे गोल्फ मदद करो।

Answer 7

सी, 182 176 128 126 125 बाइट्स

golfed:

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
}

मैंने सुना है कि कुछ मानक #includeएस को गिराना संभव है , लेकिन मैं इसे सिर्फ डाउनलोड किए गए मिंगडब्ल्यू जीसीसी कंपाइलर पर काम नहीं कर सका। यह भी पता नहीं कर सका कि #define b #includeबिना मूल्य के अधिक स्थान का उपयोग किए बिना कैसे । मैं सिर्फ एक बेवकूफ हूँ, यह उनके बिना ठीक काम करता है।

Comments

X = 0 की आवश्यकता नहीं है बल्कि इसे दूसरों के साथ घोषित करें क्योंकि यह a,b,c,d;cuz के रूप में घोषित सभी वैश्विक चर जैसे int और init भी 0 हैं क्योंकि आप कुछ भी नहीं लौटा रहे हैं जिसे आपको इसे मुख्य रूप से लिखना चाहिए ()

— मुकुल कुमार

धन्यवाद, मुझे स्टैटिक स्कोप इनिशियलाइज़ेशन के बारे में पता नहीं था। मैंने उन्हें इस तरह घोषित किया, जैसे अल्पविराम के बजाय अर्ध-कॉलोन के साथ। इसके अलावा मैंने मुख्य का उपयोग नहीं किया क्योंकि मुझे लगता है कि मुझे (int argc, char ** argv) लेने की आवश्यकता होगी और यह एक टन बाइट्स है। मुझे उम्मीद है कि इसे एक फ़ंक्शन के रूप में छोड़ देना ठीक है, हालांकि यह एक पैरामीटर और आउटपुट के रूप में इनपुट को stdout में ले जाता है जो थोड़ा विषम है।

— nmjcman101

while(i++<x) इसके बजाय का उपयोग करेंfor (...)

— मुकुल कुमार

वास्तव में अच्छा विचार है, लेकिन iलूप के लिए फिर से चलने के लिए हर बार शून्य होना चाहिए।

— nmjcman101

फिर उसी के साथ forबदलें और निकालेंi <xi++<xi++

— मुकुल कुमार

Answer 8

जावा 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;}}

-58 बाइट्स @ OliverGrégoire की बदौलत बच गए । ( अपने 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;
    }
  }
}

इनपुट: abcde
आउटपुट:

Comments

मुझे यकीन नहीं है कि यदि आपने इसे उद्देश्यपूर्ण रूप से केवल 20 लाइनें प्रति सेकंड प्रिंट करने के लिए डिज़ाइन किया है, लेकिन अगर यह आपके गोल्फ में मदद करता है, तो आपको केवल प्रति सेकंड कम से कम 20 लाइनें प्रिंट करना होगा । मुझे नहीं पता कि "प्रति सेकंड 20 गणित" को बदलने के लिए "हर दूसरे को बदलने के लिए" गणित मदद करेगा या नहीं।

— nmjcman101

आप की जरूरत नहीं है x: r+=(char)(33+Math.random()*94)। Thread.sleep(9)एक बाइट को बचाने के लिए भी ।

— ओलिवियर ग्रेजायर

इसके अलावा, r=s.substring(0,i/20)पाश के बजाय पर j।

— ओलिवियर ग्रेजायर

मेरे द्वारा किए गए महत्वपूर्ण परिवर्तनों को देखते हुए, मैंने अपना उत्तर उन टिप्पणियों के साथ पोस्ट करने का निर्णय लिया। इसके अलावा, यह बाइट काउंट (जावा-वार, आईएनसी) में कम बल्कि जाने के लिए एक जावा 8 समाधान है।

— ओलिवियर ग्राएगोइरे

@ ओलिवियरग्रेगायर धन्यवाद। और मैंने आपके उत्तर को गलत बताया है। मैंने सभी बदलाव नहीं किए हैं, केवल r.substring(0,i/20)(मेरे बारे में बहुत बेवकूफ), और (char)(33+Math.random()*94)(आप से अच्छी चाल)।

— केविन क्रूज़सेन

Answer 9

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 करने का इरादा है। ;)

इनपुट स्मृति स्थान पर एक एससीआई स्ट्रिंग दर्ज करके और उस पते को छद्म रजिस्टर में सेट करके लिया जाता है $t0। उदाहरण के लिए:

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

प्रिंग मैं उपयोग कर रहा हूँ जो कुछ भी मेमोरी में है, कुछ बाइट्स इनपुट स्ट्रिंग को अतीत में रखते हैं। 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's के बजाय का उपयोग करके गोल्फ किया जा सकता है , लेकिन यह मेरी मशीन पर बहुत धीरे-धीरे चलने का कारण बनता है, इसलिए यह प्रति सेकंड कम से कम 20 लाइनों का उत्पादन नहीं करता है, इसलिए उन बाइट्स को सहेजना नहीं है।

नमूना आउटपुट: http://pastebin.com/H4H74sAx

Answer 10

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

स्टड से इनपुट पढ़ता है।

"पासवर्ड" में प्रत्येक अतिरिक्त पत्र के बीच मेरी मशीन पर लगभग 61 लाइनें गिना।

Answer 11

बैश, 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"

बहुत बहुत धन्यवाद व्हाट्सएप संवेदनशील होने के लिए ...

वैसे भी, आउटपुट अलग-अलग लाइनों पर वास्तविक समय में दिया जाता है। एक .shस्क्रिप्ट के रूप में सहेजें और इसके साथ आह्वान करें:

bash <File Name>.sh <Input>

उदाहरण के लिए, bash Cracking_In_Progress.sh okayertyनिम्न आउटपुट में परिणाम 30 फ्रेम प्रति सेकंड दर्ज किए गए हैं:

Answer 12

हास्केल (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 बाइट्स

Comments

अछा लगता है! लेकिन >आउटपुट के अंत में ऐसा क्या है ?

— मस्त

@ यह शीघ्र है। चूंकि कोड अंत में एक नई रेखा नहीं छापता है, इसलिए वहां संकेत जाता है।

— 15

Answer 13

MATL , 26 बाइट्स

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

इसे ऑनलाइन आज़माएं!

नीचे ऑफ़लाइन कंपाइलर से रीयल-टाइम आउटपुट है। ध्यान दें कि एनिमेटेड GIF को अपने आकार को छोटा रखने के लिए 20 एफपीएस पर दर्ज किया गया था, लेकिन वास्तविक गति बहुत अधिक है।

यह काम किस प्रकार करता है

           % 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

Comments

यह कोड बहुत खुश है। :)

— sethmlarson

@SethMichaelLarson ऐसा इसलिए है क्योंकि इसके उद्धरण चिह्न संतुलित हैं, जो आम तौर पर नहीं होता है :-)

— लुइस मेंडू

Answer 14

पायथन 3, 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)))

स्टड से इनपुट।

आंखें संस्करण (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)

Comments

मुझे लगता है कि आप कुछ बाइट्स को "नाम बदलने" के लिए नहीं बचा सकते हैं जो आप केवल एक बार करते हैं। उदाहरण के लिए आपके पास है t=time.clock, लेकिन आप केवल एक बार कोड में टी का उपयोग करते हैं। इसे सिर्फ time.clock3 बाइट्स से बदलने से बचत होगी। प्रिंट के लिए एक ही बात।

— nmjcman101

@ nmjcman101 उप्स, प्रचलित क्रिया से आगे बढ़ते हैं। धन्यवाद!

— मैटसॉयज

इसके अलावा अपने 2 बाइट्स के लिए for _ in range(l-x)हो सकता है for _ in"a"*(l-x)।

— nmjcman101

@ nmjcman101 अच्छा लगा! मुझे याद है कि एक ...

— 16

print(i[:x]+''.join(map(chr,random.sample(range(32,127),l-x))))इसके बजाय की कोशिश करेंprint(i[:x]+"".join(chr(random.randint(32,126))for _ in"a"*(l-x)))

— X1Mike7x

Answer 15

नोड.जेएस, 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अधिक स्ट्रिंग-> सरणी-> स्ट्रिंग रूपांतरण ओवरहेड के बिना उपयोग करने का साइड लाभ है ।

Comments

अच्छा लगा, मुझे इसके बारे में और सीखना चाहिए Buffer। बस आप जानते हैं, किसी भी बाइट को बचाने के Dateलिए आश्वस्त Dनहीं; मैंने खुद कोशिश की।

— ETHproductions

Answer 16

पायथन 3, 167 166 बाइट्स

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)

स्टड से इनपुट पढ़ता है। एक 171-बाइट संस्करण पायथन 2 के तहत चलता है (इसके 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)

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)

Answer 17

दिल्लोग एपीएल , 59 58 बाइट्स

उपाय

⎕IO←0कई सिस्टम पर डिफ़ॉल्ट की आवश्यकता होती है।

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

प्रदर्शन

विंडो को दो लाइनों में समायोजित करने से, हमें इन-प्लेस ट्रांसफ़ॉर्मेशन का भ्रम हो जाता है:

व्याख्या

यह एक अनाम फ़ंक्शन ट्रेन है जो पासवर्ड को सही तर्क के रूप में लेती है।

⊢⊣ पासवर्ड वापस करें और के परिणाम को खारिज करें

≢{... }¨ नीचे दिए गए फ़ंक्शन, पासवर्ड की लंबाई के साथ बाएं तर्क के रूप में, प्रत्येक पर लागू होता है

 2⊃⎕AIवर्तमान अप-टाइम ( एक ccount I के विरूपण का तीसरा तत्व )

 1E3+ एक दूसरा जोड़ें

 t←आवंटित है कि करने के लिए टी

 ⊣ खारिज कर दिया

 ⍵{... }⍣{t≤2⊃⎕AI}⍺(उप-तार के साथ निम्नलिखित समारोह लागू ⍺ और के रूप में पासवर्ड लंबाई ⍵ ) बार-बार तक समय तक पहुँच जाता है टी

  ⍵⍴95 95 बार-बार दोहराया जाता है क्योंकि पासवर्ड में अक्षर हैं

  ? यादृच्छिक पूर्णांक 0 ... 94

  32+जोड़ने 32 (इस प्रकार उपज ⍵ रेंज 32 में यादृच्छिक पूर्णांकों ... 126)

  ⎕UCS यूनिकोड चरित्र में परिवर्तित करें

  ⍺, वर्तमान में संसाधित उप-स्ट्रिंग को रोकें

  ⍵↑ पासवर्ड में केवल उतने ही पात्र लें जितने की जगह

  ⎕← एक अलग लाइन पर आउटपुट

  ≢ आउटपुट स्ट्रिंग की लंबाई लौटाएं (= पासवर्ड की लंबाई)

⍳∘≢ 0 ... लंबाई -1

↑¨प्रत्येक पात्र से

⊂ पासवर्ड

Answer 18

जावा, 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);}}

केविन क्रूज़सेन के जवाब के रूप में एक ही एल्गोरिदम , केवल जावा 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");
  }
}

Answer 19

सी #, 203 197 195 190 बाइट्स

golfed:

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 भंडार की लंबाई।

StopWatchऔर Path.GetRandomFileName().NET फ्रेमवर्क के हिस्से हैं।

EDIT1: निहित Stopwatchघोषणा।

EDIT2: lआरंभिक घोषणा के साथ विलय हो गया।

EDIT3: धन्यवाद, @ क्रिस।

Comments

स्टॉपवॉच को नया रूप देने के लिए और स्पष्ट रूप से इसे शुरू करने के लिए आप स्टैटिक मेथड स्टॉपवॉच.टार्टन्यू () का उपयोग कर सकते हैं और इसे स्पष्ट रूप से शुरू कर सकते हैं

— क्रिस

@ क्रिस, मुझे उस तरीके के बारे में नहीं पता था, thx।

— पाल्दिर

t++कहीं पर भी डाला जा सकता हैif ()

— मुकुल कुमार

@ मुकुलकुमार क्या आप अधिक जानकारी प्रदान कर सकते हैं?

— राजपूत

उपयोग करें if (w.Elapsed.Seconds > t++)और निकालेंt++;

— मुकुल कुमार

Answer 20

स्काला, 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)}

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

Answer 21

फोर्सलैंग , 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

Comments

क्या आप उस प्रोग्रामिंग भाषा के लिए एक लिंक जोड़ सकते हैं जिसका आपने उपयोग किया है?

— सोलोमन उको

@SolomonUcko यहाँ तुम जाओ।

— SuperJedi224

Answer 22

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 लाइनें आउटपुट करता है) और फिर अगले "क्रैकिंग" चरण के लिए आगे बढ़ता है।

Answer 23

गो , 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
}

Answer 24

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

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

(मुझे पता है कि वीडियो बकवास है)

Comments

यह बहुत अधिक गोल्फ हो सकता है। उदाहरण के लिए, इसके बजाय $c=range(32,127)और फिर $r=chr($c[rand(0,94)]), सिर्फ क्यों नहीं $r=chr(rand(0,94)+32)?

— Xanderhall

अच्छी बात। यह मेरा पहला गोल्फ है: P

— Nino firstkopac

<?$l=strlen($a=$argv[1]);$e=$l+$s=time();while(time()<=$e&&$o!=$a){$o=substr($a,0,time()-$s);while(strlen($o)<$l)$o.=chr(rand(0,94)+32);echo "$o\n";}149 बाइट्स है, और मुझे यकीन है कि इसे आगे बढ़ाया जा सकता है

— Xanderhall

कूल, आपको उस आदमी को पोस्ट करना चाहिए।

— नीनो एकोपैक

बस अपना उत्तर संपादित करें, आपको इसे बदलने और सुधारने की अनुमति है।

— Xanderhall

Answer 25

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

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

Comments

आप आउटपुट को एक चर पर संग्रहीत क्यों नहीं करते हैं, फिर उन सभी को मिलाते -nonewlineहैं, putsपैरामीटर पर बचने के लिए ?

— सर्गियोल

मुझे लगता है कि आपको exprअंत में दोनों की आवश्यकता नहीं है ; एक पर्याप्त है, और आप आसपास के रिक्त स्थान से भी बच सकते हैं >

— सर्जियोल

धन्यवाद @sergiol, आसपास कोई रिक्त स्थान नहीं हैं>, संघनित संस्करण को देखें। कृपया सलाह दें कि exprअंत में किसी एक का उपयोग कैसे करें , मैं इसे नहीं देख सकता।

— hdrz

मेरे दो सुझावों का डेमो ।

— सर्गिओल

[set k [expr $k-1]]हो सकता है [incr k -1]। और प्रत्येक `<` हो सकता है <, कोई रिक्त स्थान की आवश्यकता नहीं है।

— सर्गिओल

Answer 26

कोटलिन, 188 बाइट्स

golfed

val x=readLine()!!;val n=System::currentTimeMillis;val t=n();do{val s=(n()-t)/1000;x.mapIndexed{i,c->print(if(i<s)c else((Math.random()*(126-32))+32).toChar())};println()}while(s<x.length)

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)

नामकरण System.currentTimeMillisने काफी कुछ बाइट्स बचाए!

Answer 27

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|और QBasic के फ़ंक्शन का उपयोग करने पर निर्भर करता है LEFT$क्योंकि मैंने QBIC में अभी तक उस फ़ंक्शन को लागू नहीं किया है ...

के लिए सभी को प्रतिस्थापित करके कुछ बाइट्स परिमार्जन करने का प्रबंधन 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

आउटपुट ('हेलोवर्ल्ड' पर मध्य भाग का एक टुकड़ा)

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