रैंडम पासवर्ड जेनरेटर

40

डोमेन सर्वर के लिए आवश्यक है कि सभी कर्मचारियों के पास निम्न नियमों के अनुरूप एक मजबूत, यादृच्छिक पासवर्ड हो:

  • बिल्कुल 15 वर्ण लंबे।
  • कीबोर्ड-टाइप करने योग्य वर्ण केवल (जैसा कि नीचे दिए गए कोड-प्रकार में दिखाया गया है)। ALT + NUMPAD कोड का उपयोग करने के लिए बिक्री सिखाने की अनुमति नहीं है।
  • कम से कम 1 निचला मामला पत्र: abcdefghijklmnopqrstuvwxyz
  • कम से कम 1 ऊपरी मामला पत्र: ABCDEFGHIJKLMNOPQRSTUVWXYZ
  • कम से कम 1 संख्यात्मक अंक: 0123456789
  • कम से कम 1 प्रतीक: `~!@#$%^&*()_+-={}|[]\:";'<>?,./

इस उद्देश्य के लिए आईटी ने कमीशन किया है और सभी कर्मचारियों को रैंडम पासवर्ड जेनरेटर वितरित करेगा। सभी कर्मचारियों को रैंडम पासवर्ड जेनरेटर का उपयोग करना आवश्यक होगा। रैंडम पासवर्ड जनरेटर के लिए आवश्यकताएं, ऊपर दिए गए पासवर्ड प्रतिबंधों के अलावा हैं:

  • यह सभी स्वीकार्य पात्रों के सभी क्रमपरिवर्तन उत्पन्न करने में सक्षम होना चाहिए।
  • इसे स्क्रीन पर उत्पन्न पासवर्ड प्रदर्शित करना होगा।
  • कोड जितना संभव हो उतना छोटा होना आवश्यक है (बाइट्स में)।

कृपया अगले सप्ताह के भीतर अपना प्रस्तावित समाधान प्रस्तुत करें।

code-golf  random 
— हाथ-ए-खाना
स्रोत
10
आपको यह भी मांग करनी चाहिए कि सभी पासवर्ड जो एक ही संभावना के साथ दिखाई देते हैं (अन्यथा मैं अनुमत पात्रों के साथ केवल 30 वर्णों की लंबी सूची बना सकता हूं, इसे फेरबदल कर सकता हूं और पहले 15 लोगों को दे सकता हूं)
— मार्टिन थोमा
@moose, सहमत हुए। मैंने एक नया नियम जोड़ा है।
— हैंड-ई-फूड
22
आईटी वालों को निकाल दिया जाना चाहिए, या कम से कम बेहतर शिक्षित किया जाना चाहिए: यदि आप पासवर्ड को यादृच्छिक रूप से उत्पन्न करते हैं, तो अनुमेय पासवर्डों के सेट को प्रतिबंधित करना जिसमें वास्तव में प्रत्येक श्रेणी का कम से कम एक वर्ण शामिल है , पासवर्ड को कमजोर करता है, क्योंकि यह आकार को कम करता है अनुमेय सेट। और हमारे कार्यक्रम उतने ही आसान होंगे अगर हमें उस के लिए जाँच नहीं करनी पड़ेगी ... ठीक है, इतनी सारी प्रस्तुतियाँ आने के बाद प्रतियोगिता को संशोधित न करें; यह एक चुनौती के रूप में ठीक है।
— MvG
10
@ एमवीजी तथ्य:correcthorsebatterystaple
— जोनाथन रीनहार्ट
1
आपने वास्तव में @moose का उत्तर इसलिए नहीं दिया है कि सभी पासवर्ड उदार हैं। उन्हें समान संभावना के साथ दिखाई देना चाहिए।
— एथन बोल्कर

जवाबों:

29

गणितज्ञ (18)

मुझे थोड़ा धोखा दे दो

= 15char ASCII pwd

&(^F7yP8k:*1P<t

पुनश्च सुरक्षा नहीं :)

— ybeltukov
स्रोत
6
कोड कहां है?
— डेविड जेएन
11
क्या प्रत्येक वर्ण वर्ग की आवश्यकता के कम से कम एक को संतुष्ट करने की गारंटी है ?
— हाथ-ई-फूड
3
@ हाथ-ई-फूड हाँ, यह है! यदि आप उस व्याख्या को देखते हैं जो आप देखेंगे: पासवर्ड की लंबाई 15, निचले-मामले के अक्षरों की आवश्यकता, ऊपरी-मामले के पत्रों की आवश्यकता, संख्याओं की आवश्यकता, विशेष वर्णों की आवश्यकता।
— ybeltukov
6
+1 चतुर, लेकिन डरपोक।
— 23
10
मुझे पता था कि गणितज्ञ के पास हर चीज के लिए एक फ़ंक्शन है, लेकिन यह ?
— कोनराड बोरोस्की
13

रूबी, 74 69 बाइट्स

सभी श्रेणियों के वर्ण मौजूद होने तक सिर्फ असिची रेंज 33 - 126 से बेतरतीब ढंग से नमूना:

$_=[*?!..?~].sample(15)*''until~/\d/&&~/[a-z]/&&~/[A-Z]/&&~/\W|_/
p$_

रूबी, 39 बाइट्स

मूस की चतुर खोज का उपयोग करना:

p"0123abcdABCD-+/<".chars.sample(15)*''
भीड़ को संतुष्ट करने के लिए संपादित करें:

ध्यान दें कि मैंने इसे पहली बार पोस्ट करने के बाद नियमों को बदल दिया । उस समय दोनों पिछली प्रविष्टियों ने नियमों पर लागू किया। मैं यह भी बताना चाहूंगा कि नियम अभी भी बहुत अच्छी तरह से परिभाषित नहीं हैं:

(..) सभी स्वीकार्य पात्रों के सभी क्रमपरिवर्तन

"क्रमपरिवर्तन"। हैं कोई क्रमपरिवर्तन स्वीकार्य वर्णों की है कि नियमों के बाकी के साथ अनुपालन करता है, स्वीकार्य पात्रों के ही सेट के रूप में लंबे समय के रूप है, क्योंकि स्वीकार्य पात्रों में से सेट के किसी भी परिवर्तन (जबकि पासवर्ड 15 वर्णों का होना माना जाता है)। और क्रमपरिवर्तन में कोई पुनरावृत्ति नहीं होती है। हालाँकि मेरी पहली प्रविष्टि अभी भी यहाँ के कई अन्य उत्तोलकों के उत्तर की तुलना में अधिक "यादृच्छिक" है।

फिर भी, यहाँ आपके पास है। वर्ण और अंडरस्कोर की पुनरावृत्ति की अनुमति देता है:

रूबी, 77 बाइट्स

$_=([*?!..?~]*15).sample(15)*''until~/\d/&&~/[a-z]/&&~/[A-Z]/&&~/\W|_/
puts$_

मैंने putsइसके बजाय इसका इस्तेमाल किया pक्योंकि p"उद्धरण चिह्नों" में संलग्न स्ट्रिंग को प्रिंट करता है और कुछ अक्षर बैकस्लैश के साथ भाग गए।

रूबी, 70 बाइट्स

जैसा कि वेंटरो बताते हैं, रेगीज़ के ~सामने छोड़ दिया जा सकता है, और printप्रतिस्थापित किया जा सकता है puts$_। लेकिन बदसूरत आउटपुट के कारण यह आपके सभी अस्वीकृत पासवर्डों को भी प्रिंट कर सकता है, इसे एक-लाइनर में निचोड़ कर:

puts$_=([*?!..?~]*15).sample(15)*''until/\d/&&/[a-z]/&&/[A-Z]/&&/\W|_/

व्याख्या

के रूप में अनुरोध किया। $_एक अर्ध-जादुई चर है जिसमें इनपुट से अंतिम पंक्ति पढ़ी जाती है - इसलिए आपको हमेशा इसे स्टोर करने की आवश्यकता नहीं है, इस तरह । यहाँ हालांकि हम इसका उपयोग एक और संपत्ति के कारण करते हैं, अर्थात् ~ऑपरेटर सीधे इसके लिए एक रेगेक्स लागू करता है, एक चाल जिसे मैंने पहली बार क्रोन द्वारा सीखा । मैंने इसके उपयोग को बदल दिया all, लेकिन यह समझने में काफी आसान होना चाहिए कि क्या आपको आराम मिलता है ( डॉक्स देखें )।

— daniero
स्रोत
2
क्या आप कृपया अपने कोड को थोड़ा समझा सकते हैं? क्या करता .all?{|r|~r}है? क्या करता $_=है?
— मार्टिन थोमा
3
नमूना लाइन चतुर और सभी है, लेकिन मुझे लगता है कि यह उल्लंघन करता है "यह सभी स्वीकार्य पात्रों के सभी क्रमपरिवर्तन उत्पन्न करने में सक्षम होना चाहिए।" कहीं भी यह नहीं कहता कि पासवर्ड में केवल वही विज्ञापन हो सकते हैं जहाँ तक अक्षरों का संबंध है। अगर z एक अनुमत वर्ण है, तो एक मौका होना चाहिए> 0 वह z पासवर्ड में है।
— नाइट्रो 2k01
1
क्या \Wअंडरस्कोर शामिल रूबी में _? अधिकांश रेगेक्स बोलियों में मुझे पता है कि यह नहीं है। और यदि आपका कोड पासवर्ड उत्पन्न नहीं कर सकता है जहां एक एकल _एकमात्र गैर-अल्फ़ान्यूमेरिक प्रतीक था, तो यह एक आवश्यकता का उल्लंघन करेगा। दूसरा दृष्टिकोण बहुत स्पष्ट रूप से उस आवश्यकता का उल्लंघन करता है, लेकिन मुझे लगता है कि यह उस समय सही ढंग से नहीं किया गया था।
— MvG
1
@ एमवीजी: आप सही हैं। \Wपर्ल-संगत RegEx ( स्रोत ) में एक अंडरस्कोर शामिल नहीं है ।
— मार्टिन थोमा
1
इसके अलावा, आपका समाधान एक ही समस्या से प्रभावित है @moose और मेरे पास पायथन था: sampleतत्वों को दोहराता नहीं है, इसलिए आपके कोड द्वारा बार-बार तत्वों के साथ पासवर्ड उत्पन्न नहीं किया जा सकता है। क्या आप अपने उत्तर को प्रश्न के अनुरूप बनाने के लिए इन दो मुद्दों को ठीक कर सकते हैं? यह देखते हुए कि आपका प्रमुख समाधान कैसे है, वुल्फराम अल्फा को छोड़कर, यह देखना अच्छा होगा कि क्या आप पुष्टि कर सकते हैं और फिर भी बढ़त बनाए रख सकते हैं। मुझे लगता है कि यह बहुत कठिन नहीं होना चाहिए।
— MvG
12

जावा 8 - 354 329 319 275 267 वर्ण

बस मज़े के लिए, जावा 8 के साथ लैम्ब्डा का उपयोग करते हुए - प्रत्येक संभावित आउटपुट में समान संभावना होती है।

यह इस तथ्य का उपयोग करता है कि अनुमत वर्णों में लगातार एएससीआई कोड हैं, 33 से 126 तक।

class A {
    //flags for, respectively, small caps, large caps, digits, punctuation
    static int a, A, d, p;

    public static void main(String[] x) {
        String s;
        do {
            //Using special String constructor that takes an int[]
            s = new String(new java.util.Random().ints(15, 33, 127)
                                .toArray(),
                           0, 15);
            a = A = d = p = 0;
            s.chars()
                .map(c ->
                      c > 96 & c < 123 ? a = 1
                    : c > 64 & c < 90  ? A = 1
                    : c > 47 & c < 58  ? d = 1
                    : (p = 1))
                .min();
        } while (a + A + d + p < 4);
        System.out.println(s);
    }
}

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

.*;Tm?svthiEK`3  
o.dzMgtW5|Q?ATo  
FUmVsu<4JF4eB]1

संपीड़ित कार्यक्रम:

class A{static int a,A,d,p;public static void main(String[]x){String s;do{s=new String(new java.util.Random().ints(15,33,127).toArray(),0,15);a=A=d=p=0;s.chars().map(c->c>96&c<123?a=1:c>64&c<90?A=1:c>47&c<58?d=1:(p=1)).min();}while(a+A+d+p<4);System.out.println(s);}}

— assylias
स्रोत
कैसे while(a+A+d+p<4)के a|=1बजाय एक साथ के बारे में a++? या बिटमास्क का उपयोग करें, जैसे कि सामान के a|=1माध्यम से a|=8, a<15लूप की स्थिति के साथ। यदि मैं सही ढंग से गिना जाता है तो यह एक और 13 वर्णों को बचाता है।
— MvG
@MvG अच्छी बात - कुछ ऐसा ही किया, मुझे लगता है कि कुछ अतिरिक्त आकर्षण की बचत।
— अस्सलास
@ एमवीजी और उपयोग करने new String(int[],int,int)से एक और 40 विषम वर्णों की बचत होती है!
— अस्सलायस
8

पायथन 2.X + 3.X (229 अक्षर): उत्पन्न करें और बदलें

विचार

  1. पहले 15 अनुमत प्रतीकों के साथ एक सूची बनाएं
  2. एक यादृच्छिक स्थिति rको एक यादृच्छिक अंक द्वारा बदलें
  3. ऊपरी स्थिति पत्र द्वारा s, एक यादृच्छिक स्थिति बदलेंs != r
  4. लोअर केस लेटर और सिंबल के लिए 2 और 3 में समान।

कोड

from random import randint as r, shuffle as s
a=list(range(15))
p=a[:]
for i in range(15):
    a[i]=chr(r(32,126))
s(p)
a[p.pop()]=chr(r(48,57))
a[p.pop()]=chr(r(65,90))
a[p.pop()]=chr(r(97,122))
a[p.pop()]=chr(r(33,47))
print(a)

पायथन 2.X + 3.X (194 अक्षर): उत्पन्न करें और जांचें

import random
from re import search as s
p=''
while not all([s("\d",p),s("[a-z]",p),s("[A-Z]",p),s("[\W_]",p)]):
 p=str(map(chr,[random.choice(list(range(33,127))) for i in range(15)]))
print(p)
  • एमवीजी के लिए धन्यवाद जिन्होंने मुझे बताया \uऔर \lपायथन रेगेक्स में मौजूद नहीं है।
  • Grc के लिए धन्यवाद जिसने मुझे बताया कि random.sampleप्रतिस्थापन के बिना हर संभव अनुमत पासवर्ड प्राप्त करने के लिए हमें प्रतिस्थापन के साथ नमूना लेने की आवश्यकता है।

समस्या वर्णन में दोष का उपयोग करना

वर्तमान में, समस्या का विवरण मांग नहीं करता है कि प्रत्येक प्रतीक / अंक समान संभावना के साथ दिखाई देते हैं। निम्नलिखित समाधान के साथ, आप किसी एकल चिह्न और / या स्थिति के बारे में कोई धारणा नहीं बना सकते। लेकिन आप इसे कई लोगों के साथ कर सकते हैं।

पायथन 2.X + 3.X (62 अक्षर)

from random import sample
print(sample("0123abcdABCD-+/<",15))

नमूना का उपयोग करने के लिए विचार के लिए डैनिएरो का धन्यवाद।

— मार्टिन थोमा
स्रोत
दोष खोजने में बहुत चिकनी! मैंने इसे पहचान लिया है, लेकिन इसे पहचानने के लिए बोनस अंक। :-)
— हैंड-ई-फ़ूड
आपका जीन और चेक मेरे दृष्टिकोण के समान है। जिज्ञासा से बाहर: यह \lऔर इतने पर अजगर रेगेक्स के लिए कहां प्रलेखित है? इसे संदर्भ में न देखें । मेरा पायथन 3.3.3 भी स्वीकार नहीं करेगा "\u"। str(…)या तो 3.3.3 या 2.7.6 में पत्र में शामिल नहीं है। ऑप्टिमाइज़ेशन के लिए एक सुझाव all(s("\\"+i,p)for i in "dluW"):।
— MvG
random.sampleप्रतिस्थापन के बिना तत्वों को चुनता है, इसलिए सभी पासवर्ड संभव नहीं हैं।
— grc
@MvG: धन्यवाद। मैंने अभी देखा है \uऔर \lकेवल विम है।
— मार्टिन थॉमा
7

बैश ऑन * निक्स (109)

while ! grep -Pq [A-Z].*[a-z].*[0-9].*[\\W_]<<<$a$a$a$a
do a=`tr -dc !-~</dev/urandom|head -c15`
done
echo $a

सही ढंग से काम करने के लिए, $aएक वैध लेकिन गैर-यादृच्छिक पासवर्ड को सामने नहीं रखना चाहिए। यदि आप शामिल करना चाहते हैं a=और एक पंक्ति टूट जाती है, तो यह तीन और वर्ण हैं लेकिन यह आपको बार-बार बात चलाने की अनुमति देता है। आप स्पष्ट रूप से सभी नई सूचियों को भी बदल सकते हैं ;ताकि आपके पास एक-लाइनर हो जिसे आप जितनी बार चाहें उतनी बार निष्पादित कर सकते हैं।

इसके अलावा, आपको LC_ALL=Cकिसी स्थानीय-विशिष्ट वातावरण चर ( LANGया LC_CTYPEविशेष रूप से) को सेट या सेट नहीं करना चाहिए , क्योंकि वर्ण श्रेणियाँ महाविद्यालय के आदेश पर निर्भर करती हैं।

/dev/urandomयादृच्छिक बाइट्स का एक स्रोत है। !-~सभी अनुमत वर्णों की श्रेणी है, जैसा कि प्रश्न में निर्दिष्ट है। tr -dcसभी पात्रों को हटा नहीं अपनी अगली तर्क में सूचीबद्ध। headशेष पात्रों में से 15 लेता है। grepजाँचता है कि क्या प्रत्येक आवश्यक प्रकार कम से कम एक बार होता है। इसके इनपुट में उम्मीदवार की चार प्रतियां शामिल हैं, इसलिए प्रतीकों का क्रम कोई मायने नहीं रखता है, इसलिए सभी संभावित पासवर्ड चयनित होने का एक मौका देते हैं। -qदबा उत्पादन grep करने के लिए।

अज्ञात कारणों से, उम्र के /dev/randomबजाय /dev/urandom। ऐसा लगता है जैसे एन्ट्रापी बहुत जल्दी थक गया। यदि आप cdमें हैं /dev, तो आप कुछ और बाइट्स से बच सकते हैं, लेकिन यह धोखा जैसा महसूस होता है।

पायथन 2 (138)

import re,random
a=''
while not re.search('[A-Z].*[a-z].*[0-9].*[\W_]',a*4):
 a=''.join(random.sample(map(chr,range(33,127))*15,15))
print a

कोड को पठनीय बनाने के लिए मैंने लूप के बाद एक नई रेखा और इंडेंटेशन जोड़ा, जो परिशिष्ट नहीं है और जिसे मैंने नहीं गिना।

यह मूल रूप से बैश संस्करण के समान ही विचार है। यहां यादृच्छिक स्रोत है random.sample, जो तत्वों को नहीं दोहराएगा। इस तथ्य का मुकाबला करने के लिए, हम अनुमेय पत्रों की सूची की 15 प्रतियों का उपयोग करते हैं। इस तरह, हर संयोजन अभी भी हो सकता है, हालांकि दोहराया अक्षरों वाले लोग अक्सर कम होंगे। लेकिन मैं इस सुविधा पर विचार करने का निर्णय लेता हूं, बग नहीं, क्योंकि प्रश्न को सभी क्रमपरिवर्तन के लिए समान संभावना की आवश्यकता नहीं थी, केवल संभावना।

पायथन 3 (145)

import re,random
a=''
while not re.search('[A-Z].*[a-z].*[0-9].*[\W_]',a*4):
 a=''.join(random.sample(list(map(chr,range(33,127)))*15,15))
print(a)

एक न्यूलाइन और एक इंडेंट की फिर से गिनती नहीं की गई। कुछ पायथन-3-विशिष्ट सिंटैक्स ओवरहेड के अलावा यह वही समाधान है जो पायथन 2 के लिए है।

जावास्क्रिप्ट (161)

a=[];for(i=33;i<127;)a.push(s=String.fromCharCode(i++));
while(!/[A-Z].*[a-z].*[0-9].*[\W_]/.test(s+s+s+s))
for(i=0,s="";i<15;++i)s+=a[Math.random()*94|0];alert(s)

मैंने पठनीयता के लिए नए अंक जोड़े, लेकिन उनकी गिनती नहीं की।

आर (114)

s<-""
while(!grepl("[A-Z].*[a-z].*[0-9].*(\\W|_)",paste(rep(s,4),collapse="")))
 s<-intToUtf8(sample(33:126,15,T))
s

लूप के अंदर लाइनब्रेक और इंडेंटेशन जोड़ा गया, लेकिन गिना नहीं गया। यदि आपको ऐसा लगता है, तो आप इसे फिर से सिंगल- ;सेपरेटेड लाइन में स्थानांतरित कर सकते हैं ।

— MVG
स्रोत
हा! मैं सिर्फ यह बताने वाला था कि आप greplअपने आर कोड में इस्तेमाल कर सकते हैं । अगर केवल मैंने चार बार टेस्ट पासवर्ड दोहराने के बारे में सोचा है तो आप एक बार में सभी जांच कर सकते हैं। और तुम्हें पता है, अगर केवल मैं के बारे में सोचा था sampleऔर intToUtf8। हालांकि, आपको यह सुनिश्चित करने के लिए अपने नमूना विधि में replace=TRUE(या अधिक संक्षेप में, आपको बस जोड़ना होगा ,T) यह सुनिश्चित करने के लिए कि आपको सभी संभव पासवर्ड मिल रहे हैं।
— अमेलियाबीआर
@ एमेलियाबीआर: आप सही हैं, उस replace=Tगलती को ठीक कर दिया, इस ओर इशारा करने के लिए धन्यवाद। ढूँढना intToUtf8टैब पूरा होने के साथ होने की संभावना के नाम का अनुमान लगाकर मुझे काफी समय लगा; मुझे पता था कि इस तरह के एक समारोह का अस्तित्व है, लेकिन अधिक सामान्य नाम chrऔर इतने पर उपयोग नहीं किया गया था।
— MvG
@ एमवीजी: मुझे समझ नहीं आता कि आपका पायथन कोड बिल्कुल समाप्त क्यों है। आपको इसकी आवश्यकता क्यों है *4? मैंने सोचा था कि आपका रेगेक्स किसी भी स्ट्रिंग से मेल खाएगा, वह विज्ञापन पहले एक अपरकेस अक्षर, फिर कुछ भी, फिर एक लोअरकेस अक्षर, कुछ भी ... मुझे क्या गलत लगा?
— मार्टिन थॉमा
@moose: जैसा कि आपने पहले ही देखा है, मेरा regex एक विशिष्ट क्रम में आवश्यक श्रेणियों के लिए जाँच करता है। लेकिन वर्तमान उम्मीदवार की चार प्रतियों को सम्‍मिलित करके, मैं यह सुनिश्चित कर सकता हूं कि यह आदेश अब मायने नहीं रखता है: यहां तक ​​कि अगर मेरा पासवर्ड प्रतीकों का अनुसरण करता है और उसके बाद अपरकेस के बाद लोअरकेस द्वारा पीछा किया जाता है, तब भी एक मैच होगा। एक मैच असफल होने का एकमात्र तरीका यह है कि क्या कोई श्रेणी पूरी तरह से गायब है। यह भी ध्यान दें कि मैं re.searchनहीं करता re.match, इसलिए रेगेक्स उम्मीदवार के पासवर्ड में कहीं भी मेल खा सकता है। क्या यह समझाता है कि यह अंततः समाप्त क्यों होगा?
— MvG
आह, मैंने नोटिस नहीं किया कि आप re.searchइसके बजाय उपयोग करते हैं re.match। इससे स्पष्ट हुआ। लेकिन मुझे अभी भी लगता है कि आपको इसकी आवश्यकता नहीं है *4। स्पष्टीकरण के लिए धन्यवाद (+1)
— मार्टिन थोमा
7

सी # ( 123 - 139 103 - 127 वर्ण संकुचित):

पूरी तरह से पर्याप्त ढांचे की विधि का उपयोग करना System.Web.dll:

class P
{
    static void Main()
    {
        Console.WriteLine(System.Web.Security.Membership.GeneratePassword(15, 1));
    }
}

जमा:

class P{static void Main()
{Console.WriteLine(System.Web.Security.Membership.GeneratePassword(15,1));}}

उदाहरण:

b+m2ae0K:{dz7:A

वैकल्पिक रूप int numberOfNonAlphanumericCharactersसे, कमांड लाइन से दूसरे पैरामीटर ( ) का मान लें :

class P
{
    static void Main(string[] a)
    {
        Console.WriteLine(System.Web.Security.Membership.GeneratePassword(15, int.Parse(a[0])));
    }
}
— रिक
स्रोत
3
GeneratePasswordप्रश्न में निर्दिष्ट प्रतीकों के पूर्ण सेट का समर्थन नहीं करता है। न ही मुझे प्रत्येक वर्ण श्रेणी की घटनाओं की न्यूनतम संख्या के बारे में कोई गारंटी मिली।
— MvG
2
आप का उपयोग करके class Pऔर आगे कॉम्पैक्ट कर सकते हैं string[] a।
— d3dave
@MvG, यह दिलचस्प है। ऐसा लगता है कि यह किसी भी प्रतीक को शामिल करता है जो आमतौर पर फ्रेंच जैसी भाषाओं में उच्चारण पात्रों को लिखने के लिए उपयोग किया जाता है। शायद एक स्मार्ट चाल है। कीबोर्ड भाषा को बदलना आपके पासवर्ड को भरने के लिए पर्याप्त होगा।
— हाथ-ई-फूड
5

आर (301 322 अक्षर)

सुधार अंकों की जांच करना भूल गया।

a='abcdefghijklmnopqrstuvwxyz';
f=as.factor(strsplit(paste(a,toupper(a),
    sep="0123456789`~!@#$%^&*()_+-={}|[]\\:\";'<>?,./"),"")[[1]]);
g=gsub("(.):","\\1",levels(q:q:q:q:q:q:q:q:q:q:q:q:q:q:q));
repeat{p=g[runif(1)*length(g)]; 
    if(grepl("[A-Z]",p)&&grepl("[a-z]",p)&&grepl("[0-9]",p)&&grepl("[^A-Za-z0-9]",p))break;};
print(p);

(व्हॉट्सएप केवल स्पष्टता के लिए जोड़ा गया)।

94 वर्णों के सभी संभावित 15-वर्ण क्रमांक बनाता है। तब तक यादृच्छिक रूप से एक का चयन करता है जब तक कि वह मानदंडों से मेल नहीं खाता।

जादू q:qऑपरेशन में है, जो एक नए कारक डेटा प्रकार को उत्पन्न करता है जो पहली qसूची में सभी कारकों की दूसरी सूची के सभी कारकों के साथ बातचीत करता है, उन दो सूचियों के हर संभव संयोजन के साथ "की सूची में शामिल किया जा रहा है" स्तर "उस कारक के। अनुमत वर्णों की सूची की 15 प्रतियों को सहभागिता करें, और आपको (94 ^ 15) संभावित स्तर मिलते हैं।

कृपया घर पर यह कोशिश न करें। सभी तीन-वर्ण क्रमपरिवर्तनों का पता लगाने के लिए कोड को कुछ सेकंड लगते हैं, मैं वास्तव में यह कल्पना नहीं कर सकता कि सभी 15-वर्ण क्रमपरिवर्तन का पता लगाने में कितना समय लगेगा, यदि आपका कंप्यूटर अभी मेमोरी से बाहर नहीं चला है इस बीच। जब मैंने इसे जांचने के लिए समाप्त (तीन-वर्ण पासवर्ड) स्क्रिप्ट को चलाया, तो पहला पासवर्ड जो "थका हुआ" था, जो मुझे लगता है कि इस कोड के लिए आपके पास होने वाली प्रतिक्रिया के बारे में है।

— AmeliaBR
स्रोत
@ एमवीजी के पास एक आर स्क्रिप्ट है जो बहुत अधिक व्यावहारिक और बहुत कम दोनों है, यदि बहुत कम भयानक है: कोडगुल्फ.स्टैकएक्सचेंज.com
— a
फिर भी, मुझे आपका विचार पसंद है। कई कोड-गोल्फ स्निपेट्स मैंने देखा कि भाषा की विशिष्ट विशेषताएं कड़ी मेहनत करती हैं। और आपका कोड निश्चित रूप से उन इंटरैक्शन के साथ R के लिए करता है।
— एमवीजी
4

गणितज्ञ 170

r=RandomSample;f[i_]:=(FromCharacterCode/@Range@@i);
{t,A,a,n}=f/@{{33,126},{65,90},{97,122},{48,57}};
s=Complement[t,A,a,n];
""<>r[Join[RandomChoice/@{A,a,n,s},r[t,11]],15]

उदाहरण

"<]} Pg3 / e? 3 + Z ~ Oz"
"X / 8jWe @ f (_x5P: ="
"2wz2VQhtJC? * R7 ^"

— DavidC
स्रोत
4

पायथन 2.7 (182)

import random as r,string as s
z=r.sample
j=list(z(s.ascii_lowercase,12)+z(s.ascii_uppercase,1)+z(s.digits,1)+z('`~!@#$%^&*()_+-={}|[]\\:";\'<>?,./',1))
r.shuffle(j)
print ''.join(j)
— जोनाथन रेनहार्ट
स्रोत
आप जुड़ाव हटाकर 9 अंक कम प्राप्त कर सकते हैं क्योंकि समस्या विवरण द्वारा इसकी आवश्यकता नहीं है। रिक्त स्थान हटाकर एक और 2 कम।
— मार्टिन थोमा
@ बार-बार टिप्पणी करने से पहले मैंने रिक्तियाँ निकाल लीं। मुझे लगता है कि joinथोड़े का होना चाहिए: क्या उपयोगकर्ताओं को आउटपुट से अजगर सूची सिंटैक्स को समझने की उम्मीद की जाएगी ['q', 'u', ...]:?
— जोनाथन रेनहार्ट
1
मैंने प्रिंट निकालने के बारे में सोचा। जब बाइट्स में आकार महत्वपूर्ण होता है, तो वे पंच कार्ड समय में रह सकते हैं। इस तरह, वे स्मृति को पढ़ने में सक्षम हो सकते हैं ... बस इसे देखकर। या वे "असली प्रोग्रामर" हैं: xkcd.com/378
— मार्टिन थोमा
1
अगर मैं कोड को सही ढंग से पढ़ रहा हूं, तो यह सभी क्रमपरिवर्तन की आवश्यकता को पूरा नहीं करता है , इसमें हमेशा 12 लोअरकेस वर्ण होंगे, जिससे अन्य समूहों में से एक के साथ पासवर्ड बनाना (जैसे aA$bc1111111111) असंभव है।
— IQAndreas
1
जॉनथॉन के बचाव में, मुझे लगता है कि उनके पद के 5 मिनट बाद क्रमपरिवर्तन नियम जोड़ा गया था।
— हाथ-ई-फूड
4

गोल्फस्क्रिप्ट (60)

के बाद से। गोल्फस्क्रिप्ट गायब है और एक noob के रूप में मुझे वैसे भी अभ्यास की आवश्यकता है :)

[48 10{rand}:r~+65 26r+97 26r+33 15r+11,{;32 96r+}%~]{r}$''+

यह सिर्फ 4 आवश्यक + 11 यादृच्छिक वर्णों के साथ एक सरणी बनाता है और यादृच्छिक क्रम में सॉर्ट करता है।

— जोआचिम इसाकसन
स्रोत
के लिए +1 {r}$। यह एक सूची में फेरबदल करने के लिए एक बहुत ही गंदा तरीका है - मुझे यह पसंद है! ;-)
— इल्मरी करोनें
... हालाँकि, मुझे नहीं लगता कि यह कभी भी उदाहरण के लिए आउटपुट कर सकता है 0Aa~~~~~~~~~~~~। :-(
— इल्मरी करोनें
3

जावास्क्रिप्ट 258 240 233 225

R=Math.random;a=b=>b[b.length*R()|0];for(x=[a(l="abcdefghijklmnopqrstuvwxyz"),a(u=l.toUpperCase()),a(n="0123456789"),a(s="`~!@#$%^&*()_+-={}|[]\\:\";'<>?,./")];15>x.length;x.push(a(l+u+n+s)));alert(x.sort(y=>.5-R()).join(""))

एक नियम का उपयोग करना जहां:

function(x){return x*x}के रूप में फिर से लिखा जा सकता है function(x)x*x। केवल मान लौटाने वाले कार्यों के लिए काम करने लगता है।

अगले चरण में, कम x.sort(function().5-R())करने के लिएx.sort(y=>.5-R())

अगला पुनरावृति, वसा तीर संकेतन के साथ और कम हो गया, जो दुख की बात है कि केवल फ़ायरफ़ॉक्स 22 और इसके बाद के संस्करण के लिए काम करता है।

— WallyWest
स्रोत
अच्छा कॉम्पैक्टिंग! : D
— IQAndreas
2

जावास्क्रिप्ट (269 अक्षर संकुचित)

स्पष्टता के लिए, यह कोड है इससे पहले कि मैंने इसे JS-Fiddle को संकुचित किया :

var lowerLetters = "abcdefghijklmnopqrstuvwxyz";
var upperLetters = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
var numbers = "0123456789";
var symbols = "`~!@#$%^&*()_+-={}|[]\\:\";'<>?,./";
var allCharacters = lowerLetters + upperLetters + numbers + symbols;

String.prototype.randomChar = function() {
    return this[Math.floor(this.length * Math.random())];
}

var minLength = 15;
var result = [];

// Start off by picking one random character from each group
result.push(lowerLetters.randomChar());
result.push(upperLetters.randomChar());
result.push(numbers.randomChar());
result.push(symbols.randomChar());
// Next, pick a random character from all groups until the desired length is met
while(result.length < minLength) {
    result.push(allCharacters.randomChar());
}
result.shuffle(); // Finally, shuffle the items (custom function; doesn't actually exist in JavaScript, but is very easy to add) -> http://stackoverflow.com/questions/2450954/how-to-randomize-shuffle-a-javascript-array
result.join("");

यहां इसे 269 वर्णों तक सीमित कर दिया गया है ( जेएस-फैडल ):

l="abcdefghijklmnopqrstuvwxyz";
u=l.toUpperCase();
n="0123456789";
s="`~!@#$%^&*()_+-={}|[]\\:\";'<>?,./";
R=Math.random;

function r(t){
    return t[~~(t.length*R())]
}

for(x=[r(l),r(u),r(n),r(s)];x.length<15;x.push(r(l+u+n+s)));
x.sort(function(){return .5-R()});
alert(x.join(""));
— IQAndreas
स्रोत
चूंकि मैं अर्ध-कॉलनों के साथ लाइनों को समाप्त कर रहा हूं, सभी हटाने योग्य व्हाट्सएप को चरित्र की गिनती के लिए नजरअंदाज कर दिया गया था, लेकिन स्पष्टता के लिए छोड़ दिया गया था।
— 23
shuffle()"कस्टम फ़ंक्शन" होने का क्या मतलब है । क्या यह जावास्क्रिप्ट का हिस्सा है या कोड आपको इसे स्वयं लिखना होगा?
— हाथ-ई-फूड
@ हाथ-ई-फूड मेरा मतलब था कि यह जावास्क्रिप्ट में नहीं बनाया गया है, और चूंकि किसी भी डेवलपर्स को यह जानना चाहिए कि किसी सरणी को कैसे फेरबदल करना है, मुझे लगा कि कोड में फ़ंक्शन सहित अनावश्यक था। यह JS-Fiddle में उपलब्ध है , हालांकि (लाइन 16)।
— IQAndreas
1
मेरा कहना है, यह आपके बाइट-काउंट की ओर गिना जाता है। लेकिन मुझे लगता है कि अब आपने इसे कॉम्पैक्ट किए गए संस्करण में लागू कर दिया है, इसलिए कृपया मुझे अनदेखा करें। :-)
— हाथ-ई-फ़ूड
2

क्लोजर (63):

(->> (map char (range 33 127)) (shuffle) (take 15) (apply str))

लेकिन यह सुनिश्चित करने के लिए सुधार किया जाना चाहिए कि प्रत्येक श्रेणी (ऊपरी, निचला, अंक, प्रतीक) में से कम से कम 1 वर्ण हो।

— ntalbs
स्रोत
2

Sql- सर्वर में

declare @a nvarchar(28)
set @a='abcdefghijklmnopqrstuvwxyz'
declare @b nvarchar(max)
set @b='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
declare @c nvarchar(max)
set @c='0123456789'
declare @d nvarchar(max)
set @d='~!@#$%^&*()_+-={}|[]\:";<>?,./'

select left(substring(@a,cast(rand()*10 as int),3)+substring(@b,cast(rand()*10 as int),6)+substring(@c,cast(rand()*10 as int),3)+substring(@d,cast(rand()*10 as int),5),15)

इसे कार्रवाई में देखें - 1

इसे एक्शन - 2 में देखें

— vhadalgi
स्रोत
1
मुझे अंतिम पंक्ति का अनुसरण करने में परेशानी हो रही है, लेकिन कोड सभी क्रमपरिवर्तन की आवश्यकता को पूरा नहीं करता है ।
— IQAndreas
आपका कोड किसी भी पासवर्ड से शुरू नहीं होगा ~0Aa, और न ही ऐसा कोई पासवर्ड b, जिसके पीछे कोई पासवर्ड हो a।
— हिनजी
@ हिनजी: हाँ मैं मानता हूँ कि सभी क्रमपरिवर्तन की आवश्यकता है जिस पर ध्यान नहीं दिया जाता है, यह सिर्फ एक 15 लंबाई को प्रदर्शित करता है..चेक करने वालों को यादृच्छिक रूप से ... z, A..Z, 0..9, ...! ... + :(। ।।
— वडालगी
2

SAS (191)

%macro c(p);compress(p,,"&p")ne''%mend;data x;length p$15;do x=1by 1;do t=1to 15;substr(p,t,1)=byte(ranuni(7)*94+33);end;if %c(kd)and %c(kl)and %c(ku)and %c(ad)then do;put p;stop;end;end;run;

*TQP,(f=h10*)S=

टिप्पणी / इंडेंट:

%macro c(p); /*compress removes or keeps certain classes of characters*/
  compress(p,,"&p")ne''
%mend;
data x;
length p$15;
do x=1by 1;
    do t=1to 15;
        substr(p,t,1)=byte(ranuni(7)*94+33); /*give it a 33-126, byte discards the noninteger portion rounding down*/
    end;
    if %c(kd)and %c(kl)and %c(ku)and %c(ad)then do; /*k=keep d=digit l/u=lower/upper ad=remove digits and alphas*/
        put p;
        stop;  /*met our requirement, head home*/
    end;
end;
run;
— जो
स्रोत
2

पॉवरशेल: 119

Gofled कोड

for(;!($x-cmatch'.*(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!-/:-@[-`{-~]).*')){$x='';1..15|%{$x+=[char](33..126|random)}}$x

अन-गोल्फ और टिप्पणी

# Start for loop definition.
for(
    # Skip variable initialization, start definition of run condition.
    ;
    # Loop runs if $x does not meet complexity requirements.
    # Length requirement is not tested here because it is enforced by the generator later.
    # Much thanks to @VasiliSyrakis for the RegEx help.
    !($x-cmatch'.*(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!-/:-@[-`{-~]).*')
)
{
    # Reset $x in case the script block has already run.
    $x='';
    # Use ForEach-Object, via the % alias, to run a loop 15 times.
    1..15|%{
        # Append a random ASCII character from 33-126 to $x.
        # Note: Use get-random instead of random for faster performance.
        $x+=[char](33..126|random)
    }
}
# Display $x.
$x
# Variable cleanup - not included in golfed code.
rv x
— Iszi
स्रोत
मुझे लगता है कि यह रेगेक्स इसे कभी भी थोड़ा कम ^.*(?=.{15,})(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!#$%&? "]).*$कर सकता है : आप इसके साथ एक मैच कर सकते हैं, जो केवल तभी मैच करेगा जब एक अपर, लोअर, डिजिट, सिंबल होगा।
— वसीली सिरैकिस
@VasiliSyrakis ठीक है, तुम मुझे उस के माध्यम से थोड़ा चलना पड़ सकता है। अगर आपको लगता है कि थोड़ी देर लगेगी, तो एक चैट रूम शुरू करें। कुछ चीजें जो मैं उलझन में हूं: 1.) मैं वहां शामिल संख्या 15 देखता हूं। यह सुनिश्चित करने के लिए कि स्ट्रिंग ठीक 15 वर्ण है? यदि ऐसा है, तो इसे छोड़ा जा सकता है, क्योंकि स्क्रिप्ट स्वाभाविक रूप से केवल 15-वर्ण तार उत्पन्न करती है। 2.) आपका क्या मतलब है "केवल एक ऊपरी, निचला, अंक, प्रतीक" होने पर मिलान होगा? यह केवल से मिलान करेगा इसका मतलब यह है जब वहाँ वास्तव में प्रत्येक में से एक, या कम से कम प्रत्येक से एक है? पूर्व चीजों को तोड़ देगा।
— इज़्ज़ी
इसके अलावा, क्या आपका RegEx वर्णों के आदेश की अनदेखी करता है? उदाहरण के लिए, यदि 4-वर्ण स्ट्रिंग्स से मिलान करने के लिए ट्यून किया जाता है, तो क्या मैच 1aZ%और (p3Rमैच दोनों होंगे ? मुझे ऑनलाइन ऐसा करने के तरीके खोजने में कुछ कठिनाई हुई।
— इज़्ज़ी
मेरे वर्तमान स्क्रिप्ट से आउटपुट के खिलाफ नए RegEx का परीक्षण किया। यह काफी विश्वसनीय नहीं लगता है। कोड: $x-cmatch'^.*(?=.{15,})(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[!#$%&? "]).*$'अच्छे मैच: C>suD1?hTwbDx(z j%4O]HyeG|u[U$5 O/rGeD0$hJk=GO/असफल मैच: 3evthX3_X^nBrR` .nA ~ uYzrR4YV-r.`u-IjZE48ntQ;HxV
— Iszi
मैं चैट रूम कैसे खोलूं?
— वासिलि सिरैकिस
1

पायथन 2.7 (149)

from random import*
''.join(map(lambda x:chr(randint(*(x[1]or(32,126)))),sorted(map(None,sample(range(15),15),((48,57),(65,90),(97,122),(33,47))))))

अधिक पठनीय (और निष्पादन योग्य नहीं) तरीके से लिखा गया;

from random import *
''.join(                                          # Concatenate characters to string
  map(                                            # Map all characters using below lambda
    lambda x:chr(randint(*(x[1] or (32, 126)))),  # Map a single range to a random character
                                                  # within a specific range if supplied,
                                                  # otherwise the default "all" range.
    sorted(                                       # After distributing ranges, sort
      map(None,                                   # zip_longest alternative, distributes the
                                                  # required ranges over 4 random positions
        sample(range(15), 15),                    # 0-14 in random order
        ((48, 57), (65, 90), (97, 122), (33, 47)) # The 4 required ranges
      )
    )
  )
)

बहुत सीधे आगे और आश्चर्यजनक रूप से "जनरेट, मैच फेल पर रिट्रीट" संस्करण की तुलना में बहुत लंबा नहीं है।

— जोआचिम इसाकसन
स्रोत
क्या आप सुनिश्चित हैं कि यह वास्तव में उदाहरण सहित सभी योग्य पासवर्ड उत्पन्न कर सकता है 0Aa~~~~~~~~~~~~? (ध्यान दें '~' == chr(126)।)
— इल्मरी करोनें '’
1

PSQL (189)

PSQL की तरह लगता है एक बिट क्रिया है ... :)

SELECT ARRAY_TO_STRING(ARRAY_AGG(CHR((TRUNC((b-a)*RANDOM()+a))::int)ORDER BY RANDOM()),'')FROM(SELECT 32 a,127 b FROM generate_series(1,11)UNION ALL VALUES(48,58),(65,91),(97,123),(33,48))a

SQLfiddle डेमो ।

— जोआचिम इसाकसन
स्रोत
1

PHP, 235 225

यह स्क्रिप्ट वर्णों के इर्द-गिर्द घूमती है और फिर RegEx के माध्यम से जाँच की जाती है ताकि यह सुनिश्चित हो सके कि पासवर्ड मजबूत है (या इसे पुनर्जीवित किया गया है)।

<?php
while(!preg_match('/^(?=.*[A-Z])(?=.*[^A-Za-z])(?=.*[0-9])(?=.*[a-z]).{15}$/',$p)){ $p = substr(str_shuffle('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`~!@#$%^&*()_+-={}|[]\:";\'<>?,./'),0,15); }
echo $p;
— ub3rst4r
स्रोत
1
चतुर, लेकिन नकली पात्रों की अनुमति नहीं देता है।
— हाथ-ई-फूड
1
इसके बजाय while(true) ... if (condition) breakआप का उपयोग कर सकते हैंwhile (!condition)
— निकलें
1

जावास्क्रिप्ट (209)

r=Math.random;function t(x,y){return String.fromCharCode(Math.floor(y*r()+x))};x=[t(33,14),t(48,10),t(65,26),t(97,26)];for(i=0;i<11;i++)x.push(t(32,95));console.log(x.sort(function(){return r()-0.5}).join(''))

अर्द्ध ungolfed;

// Return a character in the range [x,x+y)
function t(x,y) { return String.fromCharCode(Math.floor(y*Math.random()+x)) }
// Prefill required ranges
x=[ t(33,14), t(48,10), t(65,26), t(97,26)]
// Push 11 totally random (valid) characters
for(i=0; i<11; i++)
  x.push(t(32,95))
// Shuffle and output as string
console.log(x.sort(function(){return Math.random()-0.5})
             .join(''))
— जोआचिम इसाकसन
स्रोत
1

पर्ल, 92

रूबी जवाब के रूप में संक्षिप्त नहीं है, लेकिन मुझे यकीन है कि एक पर्ल विज़ार्ड इसे और भी छोटा बना सकता है ... मैं m//अंत में सभी एस के साथ बहुत खुश नहीं हूं , लेकिन लगता है कि काम करना चाहिए और अंततः उत्पन्न करने के लिए शर्तों को पूरा करना चाहिए। सभी क्रमपरिवर्तन।

do{$_=join"",map{(map{chr}33..127)[rand 94]}0..14}while!(/[A-Z]/&/[a-z]/&/\d/&/[\W_]/);print

नमूना उपयोग:

perl -e 'do{$_=join"",map{(map{chr}33..127)[rand 94]}0..14}while!(/[A-Z]/&/[a-z]/&/\d/&/[\W_]/);print'

ठीक सत्यापन और बदलने के लिए संपादित [[:punct:]]करने के लिए [\W_]MvGs टिप्पणी के बाद।

— डोम हेस्टिंग्स
स्रोत
1
आपकी पीढ़ी का हिस्सा अच्छा है, लेकिन लूप की स्थिति में आपका चयन मानदंड बिल्कुल गलत है: उदाहरण के लिए पासवर्ड के aaaaaaaaaaaaaaकारण लूप समाप्त हो जाएगा। आपको यह सुनिश्चित करने के लिए गैर-यादृच्छिक पासवर्ड के साथ मानदंडों का परीक्षण करना चाहिए कि वे वही करते हैं जो आप उन्हें चाहते हैं।
— एमवीजी
वास्तव में, आप सही हैं, मैंने इसे ठीक कर लिया है और कुछ बाइट्स बचा लिए हैं! धन्यवाद!
— डोम हेस्टिंग्स
1
क्या आप इस बारे में निश्चित हैं [[:punct:]]? मुझे लगता है कि मैं '[\ W_] , which is shorter and of which I'm even more sure that it is correct, at least combined with your 33..127' रेंज पसंद करूंगा ।
— MvG
एक अच्छा बिंदु, मुझे लगता है कि मैं चिंतित था कि \Wइसमें शामिल नहीं था _, हालांकि आप बिल्कुल सही हैं, इसकी आवश्यकता नहीं है: gist.github.com/anonymous/8301237 । धन्यवाद!
— डोम हेस्टिंग्स
1

जावा 7 ( 270 234 वर्ण)

आधार @ जावा 8 के साथ @assylias द्वारा उपयोग किया जाता है (वैध पासवर्ड तक यादृच्छिक पासवर्ड उत्पन्न करें)। हालाँकि, लैम्बदास का उपयोग करने के बजाय, पासवर्ड एक चार सरणी को पुनरावृत्त करके और एक रेगीक्स के मिलान द्वारा मान्य किया जाता है।

class A {
  public static void main(String [] a) {
    byte[] b = new byte[15];
    String s;
    do {
      new java.util.Random().nextBytes(b);
      s = new String(b);
    } while(!s.matches("(?=.*?[a-z])(?=.*?[A-Z])(?=.*?\\d)(?=.*?[!-/:-@\\[-`]).*"));
    System.out.println(s);
  }
}

न्यूनतम कोड:

class A {public static void main(String[] a){byte[] b=new byte[15];String s;do{new java.util.Random().nextBytes(b);s=new String(b);}while(!s.matches("(?=.*?[a-z])(?=.*?[A-Z])(?=.*?\\d)(?=.*?[!-/:-@\\[-`]).*"));System.out.println(s);}}
— madoke
स्रोत
1

शक्ति कोशिका

एक लाइनर संस्करण (143 बाइट्स)

sal g random;1..11|%{$P+=[char](33..126|g)};(65..90|g),(97..122|g),(48..57|g),(33..47+58..64+123..126|g)|%{$P=$P.insert((1..11|g),[char]$_)};$P

मिनी संस्करण (146 बाइट्स)

sal g random
1..11|%{$P+=[char](33..126|g)}
(65..90|g),(97..122|g),(48..57|g),(33..47+58..64+123..126|g)|%{$P=$P.insert((1..11|g),[char]$_)}
$P

पठनीय संस्करण (860 बाइट्स)

function pwgen {

    # Fulfill Upper,Lower,Digit,Symbol requirement by predefining ASCII ranges for each
    # These will be added into the string beginning at line 24

    [array[]]$symbolrange = (33..47),(58..64),(123..126)

    [char]$upper = (get-random (65..90))
    [char]$lower = (get-random (97..122))
    [char]$digit = (get-random (48..57))
    [char]$symbol = $symbolrange | get-random

    [char[]]$requirement = $upper + $lower + $digit + $symbol

    # Create the first 11 characters using any ASCII character between 32 - 126

    foreach ($number in (1..11)) {
        [string]$pass += [char](get-random (33..126))
    }

    # Insert each requirement character at a random position in the string

    foreach ($char in $requirement) {
        [string]$pass = $pass.insert((Get-Random (1..11)),$char)
    }

    return $pass
}

कोड को छोटा करने के लिए विभिन्न युक्तियों के लिए इज़ी का श्रेय।

— वसीली सिरैकिस
स्रोत
1
यह सभी क्रमपरिवर्तन को कवर नहीं करता है। एक उदाहरण के रूप में, abcd1234ABCD{|}~कभी नहीं आएगा क्योंकि $symbolकम से कम प्रतीकों में से एक ASCII 33 और 47 के बीच होना चाहिए।
— हाथ-ई-फूड
धत तेरे की! आप मेरे आलस्य को इंगित करना चाहिए !? बस मजाक कर रहा हूं ... मैंने इसे अभी संपादित किया है। मैंने प्रत्येक "आवश्यकता" चरित्र को स्ट्रिंग के भीतर एक अलग सूचकांक में जाने के बजाय, एक ही सूचकांक में एक साथ चार को टकराते हुए किया। अब अगर केवल मैं इसे छोटा कर सकता हूं ...
— वासिलि सिरैकिस
क्या कोई कारण है कि आप एक जोड़े को अधिक पात्रों को छोटा $SRकर सकते हैं, शायद $Q?
— इज़्ज़ी
तुम भी (g(65..90))नीचे की 65..90|g'. And change the ओर सामान की तरह कटौती करने में सक्षम होना चाहिए उर्फ foreach-objectका उपयोग कर छोरों को बयान %। उदाहरण: foreach($N in (1..11)){... }के रूप में संभव होना चाहिए 1..11|%{... }। मुझे पूरा यकीन है कि अन्य अनुकूलन हैं जो संभव हैं, लेकिन मुझे वास्तव में एक पूरी तरह से अलग कार्यान्वयन मिला है जिसे मैं बाद में कोशिश करने की योजना बना रहा हूं।
— इज़्ज़ी
अच्छा सुझाव :) अगर मैंने गाड़ी के रिटर्न को निकाल लिया और अर्धविराम से बदल दिया तो मैंने इसे 213 बाइट्स के लिए छोटा कर दिया।
— वसीली सिरैकिस
1

कारक, 196 वर्ण

MvG के रूप में एक ही एल्गोरिथ्म और moose है। यह सबसे छोटा नहीं है, लेकिन प्रश्न में सभी वर्तमान (वर्तमान) मानदंडों को पूरा करना चाहिए:

USING: io kernel math pcre random sequences sequences.repeating ;
[ 15 94 random-integers [ 33 + ] "" map-as dup 60 cycle
"[A-Z].*[a-z].*[0-9].*[\\W_]" findall { } = not ] [ drop ] until print
— ब्योर्न लिंडक्विस्ट
स्रोत
मैं regex की गलत व्याख्या कर सकता हूं, लेकिन मुझे लगता है ~{}|1234abcdABCDकि regex विफल हो जाएगा।
— हाथ-ई-फूड
1
यह काम नहीं करेगा:"~{}|1234abcdABCD" 60 cycle "[A-Z].*[a-z].*[0-9].*[\\W_]" findall empty? not => t
— ब्योर्न लिंडक्विस्ट
इसके लिए मुझे आप के शब्दों पर भरोसा है। :-)
— हाथ-ई-फूड
1

सी - 154 वर्ण

char p[16],c,f,w;main(){srand(time());while(f^15){c=p[15]=f=0;while(c^15){w=33+rand()%94;f|=w
>96&&w<123?1:w>47&&w<59?2:w>64&&w<91?4:8;p[c++]=w;}}puts(p);}

मुझे कैसे नफरत है srand()? मुझे रास्तों की गिनती करने दीजिए।

— ओबेरोन
स्रोत
1

हास्केल, 192

import System.Random
main=getStdGen>>= \g->(print.(take 15))$until((\x->all(any(`elem`x))[['a'..'z'],['A'..'Z'],['0'..'9'],['!'..'/']++":;<=>?@[\\]^_`{|}~"]).(take 15))tail$randomRs('"','~')g

मुद्रित स्ट्रिंग में इसके चारों ओर उद्धरण हैं और बैकस्लैश और उद्धरण वर्णों से बच जाता है; अगर यह अस्वीकार्य है, तो 3 और बाइट्स के printसाथ प्रतिस्थापित किया जा सकता है putStrLn। यहाँ अधिक पठनीय संस्करण है:

import System.Random

main = do
    g <- getStdGen
    let chars = randomRs ('"', '~') g
    let password = take 15 $ until (hasChars.(take 15)) tail chars
    print password

hasChars :: String -> Bool
hasChars x = all (any (`elem` x)) $
    [ ['a'..'z']
    , ['A'..'Z']
    , ['0'..'9']
    , "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
    ]

यह काफी सीधा है, यह सिर्फ रेंज में यादृच्छिक ASCII वर्णों की एक अनंत / आलसी सूची बनाता '!'है '~', फिर पहले तत्व को बाहर निकालता है जब तक कि पहले 15 वर्णों में आवश्यक वर्णों के प्रत्येक स्ट्रिंग से कम से कम एक वर्ण न हो।

— user3175123
स्रोत
1

एक्सेल VBA, 209 बाइट्स

For i = 1 To 15
x = x + Chr(Int(90 * Rnd + 33))
Next
p = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*(_|[^\w])).+$"
With New RegExp
.Pattern = p
Set m = .Execute(x)
If m.Count = 0 Then
MsgBox "redo"
Else
MsgBox x
End If
End With

बेतरतीब ढंग से 15 ASCII वर्ण उत्पन्न करता है ताकि सभी संभव संयोजन संभव हो सकें। फिर यह जांचने के लिए एक नियमित अभिव्यक्ति पैटर्न का उपयोग करता है कि इसमें प्रत्येक मानदंड में से कम से कम एक है।

यदि ऐसा होता है तो पासवर्ड प्रदर्शित किया जाता है, यदि "फिर से प्रदर्शित नहीं" किया जाता है।

रेगुलर एक्सप्रेशन पैटर्न के लिए बार्ट कीर्स को क्रेडिट: https://stackoverflow.com/questions/1559751/regex-to-make-sure-that-the-string-contains-at-one-one-lower-case-char-char ऊपरी

— Wightboy
स्रोत
0

ऑटोहॉटकी 352

global o:={}
loop 4
o[c()]:=o(A_index-1)
loop 11
o[c()]:=o(m(r(),4))
loop 15
s.=o[A_index-1]
msgbox % s
r(){
Random,z
return z
}
m(z,r){
return mod(z,r)
}
c(){
while o[t:=m(r(),15)]!=""
j++
return t
}
o(f){
r0:=48,l0:=10,r1:=97,l1:=l2:=26,r2:=65
r := chr(r%f%+m(r(),l%f%))
if f=3
r:=Substr("``~!@#$%^&*()_+-={}|[]\:"";'<>?,./",m(r(),32)+1,1)
return r
}

उपयोग करना - बस स्क्रिप्ट चलाएं

— एवी
स्रोत
0

अजगर (121 अक्षर)

इस तथ्य का उपयोग करता है कि आप पायथन में सूची को गुणा कर सकते हैं [1,2,3] * 2 देता है [1,2,3,1,299]। यादृच्छिक यादृच्छिक। तीन से गुणा की गई सूची में संख्या आवश्यक वर्णों के लिए असीसी तालिका में सीमाओं के बीच की सीमाएँ हैं, उदाहरण के लिए [६५, ९ ०] नक्शे अपरकेस अक्षरों में।

print "".join([random.choice([chr(i) for i in range(z[0],z[1])]) for z in [[33,48],[48,58],[58,65],[65,90],[90,123]]* 3])
— Pawelmhm
स्रोत
1
"यह सभी स्वीकार्य पात्रों के सभी क्रमपरिवर्तन उत्पन्न करने में सक्षम होना चाहिए।" मुझे नहीं लगता कि ऐसा होता है कि चूंकि रेंज हमेशा एक ही क्रम में लागू होती हैं ...?
— जोआचिम इस्कसन
आपने सही कहा, धन्यवाद। वास्तव में मैंने यह नहीं देखा कि श्रेणियों को यादृच्छिक क्रम में लागू किया जाना चाहिए, उन्हें फेरबदल किया जाना चाहिए, मैं इसे एक क्षण में संपादित करूंगा।
— पावेलम
यह वास्तव में import randomकोड में शामिल करने की जरूरत है ।
— मेगो
0

PHP 5.5 (230 बाइट्स)

echo preg_replace_callback('/./', function ($a)
{
  return chr([rand(33, 126), rand(48, 57), rand(65, 90), rand(97, 122), ord(str_shuffle('`~!@#$%^&*()_+-={}|[]\:";\'<>?,./')[0])][$a[0]]);
}
, str_shuffle(str_pad('1234', 15, 0)));

या एक लाइन पर (211 बाइट्स)

echo preg_replace_callback('/./',function($a){return chr([rand(33,126),rand(48,57),rand(65,90),rand(97,122),ord(str_shuffle('`~!@#$%^&*()_+-={}|[]\:";\'<>?,./')[0])][$a[0]]);},str_shuffle(str_pad('1234',15,0)));
— MichaelRushton
स्रोत
हमारी साइट का प्रयोग करके, आप स्वीकार करते हैं कि आपने हमारी Cookie Policy और निजता नीति को पढ़ और समझा लिया है।
Licensed under cc by-sa 3.0 with attribution required.