XKCD पासवर्ड जेनरेटर

34

परिचय

जाहिर है, यह सवाल यहां पूछा गया है और यह दुर्भाग्य से बंद हो गया है। मुझे लगा कि इसके साथ फिर से कोशिश करना एक अच्छा विचार है, लेकिन सही किया।

XKCD यह देखती है कि हमें "पासवर्ड याद रखने के लिए कठिन" का उपयोग करने के लिए कैसे प्रशिक्षित किया जाता है, यह सोचकर कि यह सुरक्षित है, लेकिन इसके बजाय एक कंप्यूटर को क्रैक करने में 3 दिन लगेंगे। दूसरी तरफ, 4-5 शब्दों को याद रखने से कुआन के पासवर्ड का पता चलता है, और याद रखना आसान है। पागल कैसे काम करता है, हुह?

चुनौती

आज का काम शब्दों का उपयोग करके 5 पासवर्ड बनाना है। प्रति शब्द 4 शब्द और न्यूनतम 4 अक्षर प्रति शब्द, लेकिन अधिकतम नहीं। कुआन के पासवर्ड इंट्रॉपी की गणना हर पासवर्ड के लिए करनी होगी, लेकिन एक मजबूर न्यूनतम सेट नहीं किया जाएगा।

क्या है कुआन का पासवर्ड इंट्रॉपी?

कुआन के पासवर्ड इंट्रॉपी एक माप है कि कुआन के अनुसार पासवर्ड कितना अप्रत्याशित है। एक सरल गणना है: ई = लॉग 2 (आर) * एल । ई कुआन का पासवर्ड इंट्रॉपी, आर उपलब्ध पात्रों की श्रेणी और पासवर्ड की लंबाई के लिए एल।

उपलब्ध वर्णों की श्रेणी आत्म व्याख्यात्मक है। यह उन वर्णों की श्रेणी है जो एक पासवर्ड हो सकते हैं, इस मामले में ऊपरी और निचला मामला है। चूंकि वर्णमाला में 26 वर्ण हैं, पासवर्ड की पूरी श्रृंखला में 26 x 2 = 52 वर्ण हैं।

पासवर्ड की लंबाई भी आत्म व्याख्यात्मक है। यह निर्माण के बाद पासवर्ड की कुल लंबाई है।

प्रतिबन्ध

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

उत्पादन

TriedScarProgressPopulation 153.9
TryingPastOnesPutting 119.7
YearnGasesDeerGiven 108.3
DoubtFeetSomebodyCreature 142.5
LiquidSureDreamCatch 114.0
code-golf  math 
— KuanHulio
स्रोत
16
परीक्षण मामलों के लिए, पासवर्ड एंट्रॉपी अलग क्यों है ? एक ही शब्दकोश से उत्पन्न होने वाले सभी 4 शब्द पासवर्ड में एक ही एंट्रोपी होनी चाहिए।
— NonlinearFruit
20
पासवर्ड एन्ट्रॉपी प्रतीक सेट पर निर्भर है। यदि आपका पासवर्ड Nसेट से प्रतीक है S, तो पासवर्ड एंट्रॉपी है log2(|S|)*N। यहाँ प्रतीक सेट का आकार शब्दकोश के आकार ( |S|=4284) और प्रतीकों की संख्या शब्दों की संख्या ( N=4) है, इसलिए प्रत्येक पासवर्ड के लिए एन्ट्रापी है 48.3।
— NonlinearFruit
48
एंट्रोपी की यह परिभाषा खतरनाक रूप से गलत है! यदि प्रत्येक वर्ण R के आकार के सेट से समान रूप से यादृच्छिक पर चुना जाता है, तो वास्तव में एक लंबाई-L पासवर्ड में R ^ L संभावनाएं होती हैं, इसलिए एन्ट्रॉपी उसी का लॉग होता है: log₂ (R ^ L) = log₂ (R) * L जो आपका सूत्र है हालाँकि, यदि पासवर्ड अलग सेट से यादृच्छिक पर चुना जाता है (जैसे कि आपके पास कभी भी पासवर्ड नहीं होगा 3t1ta#asd), तो एन्ट्रापी संभव पासवर्ड की संख्या का लघुगणक होगा। यदि आप हमेशा 4284-शब्द शब्दकोश से यादृच्छिक रूप से 4 शब्द समान रूप से चुनते हैं, तो 4284 ^ 4 पासवर्ड हैं, प्रत्येक में एंट्रॉपी log₂ (4284) * 4 .2 48.26 हैं।
— श्रीवत्सआर
5
रिकॉर्ड के लिए, इस तरह के पासवर्ड XKCD कॉमिक से पहले होते हैं। उन्हें "डाइकवेयर" पासवर्ड कहा जाता है।
— user2428118
5
यादृच्छिक वर्णों की तुलना में कम एन्ट्रॉपी वाले शब्दों के मुद्दे के अलावा, आपके प्रश्न के लिए आवश्यक है कि शब्दों को कैपिटलाइज़ किया जाए, जिसका अर्थ है कि मामला तय हो गया है और एंट्रोपी के लिए नहीं गिना जा सकता है।
— नीट द डार्क एबसोल

जवाबों:

13

पायथन 2, 102 101 97 91 बाइट्स

from random import*
exec"x=''.join(x.title()for x in sample(f,4));print(x,57*len(x)/10);"*5

शब्दकोश को एक सूची के रूप में माना जाता है f।

फ़ाइल को सहेज कर dict.txtऔर कॉल करके परीक्षण किया जा सकता है

f = open('dict.txt').readlines()
— Martmists
स्रोत
पायथन की सूची में फेरबदल की विधि नहीं है, और आप आसपास के कोष्ठक को हटाकर पायथन 2 में दो बाइट्स बचा सकते हैं exec( execपायथन 2 में एक कीवर्ड है)।
— कोनराड बोरोस्की
@xfix हाँ यह होना चाहिए shuffle(f);।
— जोनाथन एलन
वूप्स, उस asap को ठीक करना
— Martmists
4
आप इस बात पर ध्यान देने की मेरी चाल का उपयोग कर सकते हैं कि 5.7 पर गोलाई 1 दशमलव स्थान के लिए ठीक है, जब तक कि फ़्लोटिंग पॉइंट त्रुटियां पेश नहीं की जाती हैं और पांच बाइट्स बचाएं 57*len(x)/10.। एक और बाइट बचाएं जिससे प्रिंट बनाने वाले कोष्ठकों को हटाकर एक टुप ले। यहाँ एक कट-डाउन संस्करण है: टीआईओ
— जोनाथन एलन
के sample(f,4)बजाय का उपयोग करें shuffle। इसके अलावा fबस हो सकता है open('dict.txt').read().split('\n'), open('dict.txt').readlines()या बस open('dict.txt')(मुझे पता है कि यह गोल्फ नहीं है लेकिन अभी भी है)।
— एलेक्स हॉल
10

पावरशेल (3.0+), 77 बाइट्स

1..5|%{($p=-join($d|random -c 4|%{culture|% te*|% tot* $_}));57*$p.Length/10}

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

जोनाथन एलन की 57*len/10चाल का उपयोग करना ।

$dशब्दकोश में शब्दों की एक सरणी के रूप में शामिल है। यदि आप घर पर खेल रहे हैं और भरना चाहते हैं $d:

$d=-split(irm pastebin.com/raw/eMRSQ4u2)

(Get-Culture).TextInfo.ToTitleCase()पहले अक्षर को कैपिटल करने के लिए एक गोल्फ संस्करण का उपयोग करना ; मुझे नहीं लगता कि PowerShell में ऐसा करने का कोई छोटा तरीका है।

बाकी मैं बहुत सीधा हूं।

TIO लिंक में पूरा शब्दकोश है; कैश अक्षम करें और पागल हो जाएं!

— briantist
स्रोत
क्या कोई मुझे "जोनाथन एलन के 57 * लेन / 10 चाल" के संदर्भ में बता सकता है?
— जेम्स क्यूरन ने
@JamesCurran उनके उत्तर के टूटने को देखें , और इस उत्तर पर उनकी टिप्पणी भी ।
— रिश्वतखोर
यह 2.0 सही में काम नहीं करेगा। शीर्षक में इस पर ध्यान दिया जाना चाहिए। मुझे यह भी लगता है कि आपको $dयह मानने की जरूरत है कि यह पर्यावरण में मौजूद है। (gc d)| random..जहाँ शब्दकोश एक फ़ाइल है जिसे उसी निर्देशिका में d कहा जाता है।
— मैट
1
SO पर @Matt मैं v2 (या 2 संस्करण) के साथ उत्तर कार्य करने के लिए अपने रास्ते से बाहर जा सकता हूं, लेकिन यह गोल्फ खिलाड़ी है! जितना अधिक
— आर्कन
1
मैं अपने उत्तर शीर्षक में बाइट्स को बचाने की कोशिश कर रहा हूं।
— मैट
7

जेली , 22 बाइट्स

Ẋḣ4ŒtFµL×57÷⁵⁸,K
çЀ5Y

पात्रों की सूची की सूची लेती हुई एक विचित्र कड़ी, पार्स किया हुआ शब्दकोश (जैसा कि चैट में अनुमति है )।

इसे ऑनलाइन आज़माएं! (शब्दकोश छिपाने और स्क्रॉल करने की आवश्यकता को कम करने के लिए "तर्क" पर क्लिक करें।)

कैसे?

चूंकि शब्दकोश में केवल मान्य शब्द ( 4वर्ण या अधिक, केवल [a-z]) शामिल हैं, इस स्थिति को जांचने की कोई आवश्यकता नहीं है।

चूंकि शब्दकोश में सभी शब्दों में लंबाई है [4-8]संभव पासवर्ड लंबाई में हैं [16,32]संभव entropies होगा कभी नहीं दौर एक दशमलव स्थान के लिए अलग तरह से बदल कर की तुलना में, और log(52,2)साथ 5.7। केवल समस्या यह है कि के एक चल बिन्दु मान का उपयोग कर रहा है 5.7चल बिन्दु दे देंगे लंबाई के लिए त्रुटियों गोलाई 18, 26, और 31। हालांकि से गुणा करने 57और फिर से विभाजित 10का उपयोग कर ×57÷⁵से बचा जाता है यह (जबकि अभी भी उपयोग करते हुए पूर्ण चल बिन्दु परिशुद्धता मूल्य मुद्रण की तुलना में एक बाइट कम किया जा रहा है ×52l2¤)।

çЀ5Y - Main link: list of list of characters (the parsed dictionary)
   5  - literal 5
 Ѐ   - map across the implicit range [1,2,3,4,5]:
ç     -   last link (1) as a dyad
    Y - join with newlines
      - implicit print

Ẋḣ4ŒtFµL×57÷⁵⁸,K - Link 1, get password and entropy: list of lists of characters, number
Ẋ                - shuffle the list of lists (shuffle all the words)
 ḣ4              - head to 4 (the first four words)
   Œt            - title case (make the first letter of each uppercase)
     F           - flatten into one list of characters
      µ          - monadic chain separation, call that p
       L         - length of p
         57      - 57
        ×        - multiply
            ⁵    - 10
           ÷     - divide -> entropy to 1 decimal place
             ⁸   - link's left argument, p
              ,  - pair -> [p, entropy]
               K - join with (a) space(s)
— जोनाथन एलन
स्रोत
5

रूबी, 89 83 बाइट्स

d.select!{|w|w[3]}
5.times{p w=d.sample(4).map(&:capitalize)*'',5.700439718*w.size}

मान लें कि पासवर्ड चर में संग्रहीत हैं d। आप इस लाइन को कोड से पहले जोड़ सकते हैं:

d=$<.map(&:chomp)

और इस तरह से स्क्रिप्ट के लिए कॉल करें:

$ ruby generate_passwords.rb < dictionary_file.txt

नमूना उत्पादन:

"MarginStarvedOnusInsulted"
142.51099295
"KitchenMiseryLurkJoints"
131.110113514
"InducesNotablePitfallsPrecede"
165.312751822
"FarmersAbortFutileWrapper"
142.51099295
"RoutesBishopGlowFaithful"
136.81055323200002

किचनमिसरीलर्कजॉइंट्स ... वाह।

-अजीडी 32 से 6 बाइट्स

— daniero
स्रोत
1
हटाने shuffle!और बदलने के popसाथ कुछ बाइट्स को बचाने में सक्षम हो सकता है sample।
— अजेडी ३२
@ Ajedi32 ओह, तुम सही हो! मैंने वास्तव में इसके बारे में सोचा था, लेकिन मैंने इस नियम को गलत समझा था A word cannot reappear in the same password, यह सोचकर कि सभी पासवर्डों में शब्दों का पुन: उपयोग नहीं किया गया है । धन्यवाद :)
— दानिएरो
4

गणितज्ञ, 178 बाइट्स

t=1;l=Length;While[t<6,s=RandomChoice[Import["https://pastebin.com/raw/eMRSQ4u2"],4];c=Capitalize/@s;f=Flatten@Characters[c];Print[StringJoin[c]," ",Log[2,l@Union@f]*l@f//N];t++]

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

ctrl-v और प्रेस शिफ्ट + एंटर का उपयोग करके कॉपी और पेस्ट करें

गणितज्ञ, 136 बाइट्स

यह मानते हुए कि एम कोड है

m=ImportString[Import["C:\a.txt"]]

।

t=1;l=Length;While[t<6,s=RandomChoice[m,4];c=Capitalize/@s;f=Flatten@Characters[c];Print[StringJoin[c]," ",Log[2,l@Union@f]*l@f//N];t++]
— J42161217
स्रोत
"काम आज शब्दों का उपयोग करके 5 पासवर्ड बनाने के लिए है।" एक के बजाय 5 की आवश्यकता है।
— कुआनहुलियो
ठीक है ... 5 पासवर्ड .. निश्चित ..
— J42161217
आपने हाइपरलिंक पाठ से बचने के लिए कोड को छोटा करने के लिए डिक्शनरी को उपलब्ध क्यों नहीं कराया?
— सर्गियोल
आपके लिए इसका परीक्षण करना आसान हो ...
— J42161217
परीक्षण को आसान बनाने के लिए यह सरल, अनलॉल्फ़्ड हेल्पर कोड प्रदान करना सबसे अच्छा है क्योंकि यह आपके सबमिशन को कम करने के लिए है ताकि यह स्व-निहित हो। साथ ही, डिक्शनरी को स्थानीय डीएनएस सर्वर को हाईजैक किए बिना (या hostsफ़ाइल को संशोधित करने के लिए ) माना जाता है ।
— wizzwizz4
4

बैश ,66 65 बाइट्स

for w in `shuf -n4 -`;{((l+=${#w}));printf ${w^};};bc<<<$l*5.7004

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

शब्दकोश एसटीडीआईएन द्वारा पुनर्निर्मित किया जाता है। शब्दकोश में सभी शब्दों को फेरबदल और पहले 4 आउटपुट।

प्रत्येक शब्द के लिए, var l में अपनी लंबाई जोड़ता है, और बड़े शब्द को गूँजता है। अंत में गणित करने के लिए ई.पू.

अजीब समाधान, 112 बाइट्स, चार पासवर्ड:

shuf -n16 -|xargs -n4|awk '{for(i=1;i<5;i++)printf toupper(substr($i,1,1))substr($i,2);print(length($0)-3)*5.7}'
— marcosm
स्रोत
3

(यह मार्टमिस्ट्स के उत्तर का एक अनुकूलन है, लेकिन मेरे पास टिप्पणी करने के लिए रिपीट नहीं है)

पायथन, 88 86 बाइट्स

g={*f}
exec('x="".join(g.pop().title()for i in "a"*4);print(x,len(x)*5.700439718);'*5)

कैसे setnondeterministic है शोषण करके , आप किसी भी अनियमितता पुस्तकालयों को आयात करने से बच सकते हैं।

— dain
स्रोत
यह लगातार मेरे लिए एक ही आउटपुट का उत्पादन करता है। यदि यह कुछ कार्यान्वयन पर काम करता है तो आप कुछ बाइट्स बचाकर कर सकते हैं set(f).pop()।
— जोनाथन एलन
1
मुझे नहीं लगता कि यह वास्तव में वैध है। यह नियतात्मक नहीं है, इसलिए इसे एक ही पासवर्ड का उत्पादन करने की गारंटी नहीं है, लेकिन व्यवहार में यह शायद ही कभी अलग परिणाम देगा।
— DJMcMayhem
मुझे संदेह था कि यह कार्यान्वयन-निर्भर हो सकता है। मैंने इसे एनाकोंडा पायथन 3 की एक ताज़ा-रिलीज़ की गई विंडोज रिलीज़ पर किया था, और इसने काम किया। हालाँकि set(f).pop()यह काम नहीं करता है, मैंने इसे आज़माया। यह हर बार एक ही परिणाम देता है।
— dain
"व्यवहार में यह शायद ही कभी अलग परिणाम देगा" - यह मेरे लिए लगता है, यहां एक नमूना है: pastebin.com/raw/ZHiHgzxV
— dain
@ मैं उत्सुक हूं। कृपया अपने पायथन बिल्ड के बारे में जानकारी प्रदान करें।
— wizzwizz4
3

जाप , 30 बाइट्स

5Ç[V=Uö4 ®g u +Zt1ìMm52 *Vl]¸

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

— ल्यूक
स्रोत
अच्छा! लेकिन दुर्भाग्य से यह 5 बार एक ही पासवर्ड बनाता है, और यह हर बार अलग होना चाहिए ..
— इयान वार्ड
यह 30 वर्ण हो सकता है, लेकिन कम से कम UTF-8 में, मेरा सिस्टम इसे 35 बाइट्स में देखता है।
— एक CVn
1
@ MichaelKjörling Japt ISO 8859-1 का उपयोग करता है, UTF-8 का नहीं।
— डेनिस
@ डेनिस दिलचस्प। धन्यवाद।
— एक CVn
3

जावास्क्रिप्ट (ईएस 6), 164 बाइट्स

d=>{for(i=5;i--;)console.log(p="....".replace(/./g,_=>(w=d.splice(Math.random()*d.length|0,1)[0])[0].toUpperCase()+w.slice(1)),(Math.log2(52)*p.length).toFixed(1))}

मान लें कि फ़ंक्शन को सरणी के रूप में फ़ंक्शन में पास किया गया है।

टेस्ट स्निपेट

— जस्टिन मेरिनर
स्रोत
2

गणितज्ञ, 71 बाइट्स

शब्दकोश मानते हुए पहले से ही एक सरणी में लोड किया जाता है जिसे कहा जाता है d।

Table[{#,Log[2,52]StringLength[#]}&[""<>Capitalize@d~RandomSample~4],5]

explaination:

                                        Capitalize@d                    - Capitalize all the dictionary
                                                    ~RandomSample~4     - make an array with 4 values. By default values can not repeat.
                                    ""<>                                - Concatenate with empty string to turn array into single string.
      {#,Log[2,52]StringLength[#]}&[                               ]    - Put current string next to log(2,52) times length of current string
Table[                                                              ,5] - Repeat this 5 times.
— इयान मिलर
स्रोत
एन्ट्रापी संख्या के बारे में क्या ?!
— जोनाथन एलन
उफ़ वो छूट गई। अपडेट किया गया।
— इयान मिलर
2

कोल्डफ्यूजन 216 बाइट्स

p={};z=arrayLen(c);for(x=0;x<5;x++){pw="";r={};while(structCount(r)<4){n=RandRange(1,z);r.append({"#c[n]#":true});}for(w in structKeyList(r)){pw&=REReplace(w,"\b(\w)","\u\1","All");};p.append({"#pw#":57*len(pw)/10})}

यह कोल्डफ्यूजन 11+ और लुसी 4.5+ में काम करता है

इसे चलाने के लिए: https://trycf.com/gist/ff14e2b27d66f28ff69ab90365361b12/acf11?theme=monokai

TryCF लिंक में कम-गोल्फ-ईश लेकिन समान कोड है।

मुझे वास्तव में प्रतिस्पर्धी गोल्फिंग जवाब की उम्मीद नहीं थी; मैं बस यह देखना चाहता था कि कोल्डफ्यूजन में इस चुनौती को पूरा करने में क्या लगेगा। खासकर जब से इन उत्तरों में बहुत सीएफ नहीं है। :-) सेटअप के बाद, यह आश्चर्यजनक रूप से मेरी अपेक्षा से कम था।

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

— शॉन
स्रोत
2

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

यह मेरा पहला कोड गोल्फ चैलेंज है जो मैंने किया है! मुझे पता है कि यहां पर अन्य पायथन उत्तर हैं (जो कि शायद मेरी तुलना में बेहतर हैं) लेकिन यह मजेदार लग रहा था, और इसलिए मैं किसी भी रास्ते की कोशिश करना चाहता था। यहाँ गोल्फ संस्करण है:

import random, math
with open("d") as f: d=f.read()
l=d.split()
for a in range(5):
 u=[]
 p=""
 for b in range(4):
  w=random.choice([w for w in l if not w in u and len(w)>=4])
  u.append(w)
  w=w.title()
  p+=w
 print("%s %s"%(p,math.log2(52)*len(p)))

मैं इसे ऑनलाइन आज़माऊँगा! लिंक, लेकिन यह कई फ़ाइलों का समर्थन नहीं करता है। तो यहाँ एक repl.it लिंक है: https://repl.it/InIl/0

इसके अलावा, यहाँ एक अनगुल्ड संस्करण है:

import random
import math
with open("d") as f:
    dictionary = f.read() #this is the dictionary text file, simply saved as "d" as to use as few bytes as possible
words = dictionary.split() #here we turn that dictionary string into a list
for a in range(5): #here we iterate through 5 passwords
    used_words = []
    password = ""
    for b in range(4): #here we iterate through the 4 words in each password
        word = ""
        word = random.choice([word for word in words if not word in used_words and len(word) >= 4]) #Thanks to blackadder1337 from #python on freenode IRC for helping me with this.
        used_words.append(word)
        word = word.title()
        password = password + word
    print("%s %s"%(password, math.log2(52) * len(password)))

जैसा कि मैंने कहा, यह मेरा पहली बार कोड gofling है, इसलिए मुझे यकीन है कि इसमें बहुत सुधार किया जा सकता है।

— ATMunn
स्रोत
PPCG में आपका स्वागत है!
— टेलर स्कॉट
2

tcl, 137

यकीन के लिए विजेता नहीं है, लेकिन मुझे लगता है कि यह थोड़ा अधिक गोल्फ हो सकता है।

time {set p "";time {set p [string totitle [lindex $d [expr int(rand()*[llength $d])]]]$p} 4;puts $p\ [expr 5.7004*[string length $p]]} 5

डेमो - लाइन 1 उद्देश्य केवल शब्दकोश सामग्री को चर में डालना हैd

— sergiol
स्रोत
आप शायद इसे नीचे रख सकते हैं क्योंकि पासवर्ड के लिए 5 के बजाय 4 शब्दों की आवश्यकता होती है
— कुआनहुलियो
और आपने 4. LOL के बजाय 5 पासवर्ड मांगे! मैंने नंबर बेमेल कर दिया!
— सर्गियोल
Hahaha! @sergiol
— कुआनहुलियो
फिक्स्ड! @ कुआनहुलियो
— सर्गियोल
वह बेहतर है। अच्छी नौकरी।
— कुआनहुलियो
0

विम, 87 कीस्ट्रोक

qq:r!echo "$RANDOM"l<CR>D:w o|e w<CR>@"ev4bd:w|bp<CR>p0~wX~wX~wX~Y:.!wc -c<CR>A*5.7003<Esc>:.!bc<CR>PJq4@q

मान लेता है कि शब्दकोश नाम की फ़ाइल में है w। हमेशा 4 लगातार शब्दों का उपयोग करेंगे

स्पष्टीकरण:

qq                       Start recording a macro named 'q'
:r!echo "$RANDOM"l<CR>   Append the result of the shell command `echo "$RANDOM"l`
D                        Delete what you just appended
:w o|                    Save the buffer to the file 'o' and ..
e w<CR>                  Open the file 'w'
@"                       Execute the text we deleted as a normal-mode command
                         This will move the cursor a random number of characters
                         to the right
e                        Go to the end of the next word
v4bd                     Delete 4 words backwards
:w|                      Save the file and ..
bp<CR>                   Open the last buffer (the 'o' file)
p                        Paste the 4 words we deleted
0                        Move the cursor to the beginning of the line
~wX~wX~wX~               Remove the spaces between the words and capitalize
Y                        Copy current line
:.!wc -c<CR>             Pipe the current line through 'wc -c'
A*5.7003<Esc>            Append "*5.7003" to the end of the line
:.!bc<CR>                Pipe the current line through 'bc'
P                        Paste the password above the current line
J                        Join with line bellow
q                        Stop recording the 'q' macro
4@q                      Run the 'q' macro 4 times
— BlackCap
स्रोत
0

q / kdb +, 76 74 65 56 बाइट्स

समाधान:

{(x;5.70044*(#)x)}(,/)@[;0;upper]each -4?" "vs(*)(0:)`:w

उदाहरण:

q){(x;5.70044*(#)x)}(,/)@[;0;upper]each -4?" "vs(*)(0:)`:w
"RulingOverheadSaddensPriest"
153.9119

स्पष्टीकरण:

शब्द सूची में पढ़ें, "पर अलग", इस सूची से 4 यादृच्छिक शब्द चुनें, प्रत्येक शब्द के पहले अक्षर को अपरकेस करें, फिर एक साथ जुड़ें। इसे एक लैम्ब्डा फ़ंक्शन में फ़ीड करें जो पासवर्ड और गणना की गई 'एन्ट्रॉपी' लौटाता है:

                                                     `:w / the wordlist is a file called 'w'
                                                 (0:)    / read in the file list (\n separated list)
                                              (*)        / take first (and only) item in the list
                                         " "vs           / split this on " "
                                      -4?                / take 4 random items from this list, neg means 'dont put back'
                      @[; ;     ]                        / apply a function to variable at indices (variable is implicit)
                           upper                         / uppercase (the function being applied)
                         0                               / index 0, the first character
                                 each                    / each of the 4 random items
                  (,/)                                   / 'raze' (flatten lists)
{                }                                       / anonymous lambda function
 (x;            )                                        / a 2-item list, x is first item
            (#)x                                         / count x, return the length of the list
    5.70044*                                             / multiply by 5.70044

टिप्पणियाँ:

मैंने इसके बजाय 5.70044 का उपयोग किया 2 xlog 52 xexp...

— streetster
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.