Der Domänenserver erfordert, dass alle Mitarbeiter ein sicheres, zufälliges Kennwort haben, das den folgenden Regeln entspricht:

• Genau 15 Zeichen lang.
• Nur Zeichen, die über die Tastatur eingegeben werden können (siehe Code-Typ unten). Es ist nicht gestattet, den Verkäufern die Verwendung von ALT + NUMPAD-Codes beizubringen.
• Mindestens 1 Kleinbuchstabe: abcdefghijklmnopqrstuvwxyz
• Mindestens 1 Großbuchstabe: ABCDEFGHIJKLMNOPQRSTUVWXYZ
• Mindestens 1 Ziffer: 0123456789
• Mindestens 1 Symbol: `~!@#$%^&*()_+-={}|[]\:";'<>?,./

Zu diesem Zweck hat die IT einen Zufallskennwortgenerator in Auftrag gegeben, der an alle Mitarbeiter verteilt wird. Alle Mitarbeiter müssen den Zufallspasswortgenerator verwenden. Die Anforderungen für den Zufallspasswortgenerator sind zusätzlich zu den obigen Passworteinschränkungen:

• Es muss in der Lage sein, alle Permutationen aller zulässigen Zeichen zu generieren.
• Es muss das generierte Passwort auf dem Bildschirm anzeigen.
• Der Code muss so klein wie möglich sein (in Byte).

Bitte reichen Sie Ihren Lösungsvorschlag innerhalb der nächsten Woche ein.

Mathematica (18)

Lass mich ein bisschen schummeln

= 15char ASCII pwd

&(^F7yP8k:*1P<t

PS nicht Sicherheit :)

Ruby, 74 bis 69 Bytes

Nur zufällig aus dem ASCII-Bereich 33 - 126 auswählen, bis alle Zeichenklassen vorhanden sind:

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

Ruby, 39 Bytes

Mit Elchs kluger Entdeckung:

p"0123abcdABCD-+/<".chars.sample(15)*''

Beachten Sie, dass sich die Regeln geändert haben, nachdem ich dies zum ersten Mal gepostet habe. Zu diesem Zeitpunkt galten beide vorherigen Einträge für die Regeln. Ich möchte auch darauf hinweisen, dass die Regeln noch nicht zu genau definiert sind:

(..) alle Permutationen aller zulässigen Zeichen

"Permutationen". Es gibt keine Permutationen der zulässigen Zeichen, die den übrigen Regeln entsprechen, da jede Permutation des Satzes zulässiger Zeichen so lang ist wie der Satz zulässiger Zeichen selbst (während das Kennwort 15 Zeichen lang sein soll). Und es gibt keine Wiederholungen in einer Permutation. Mein erster Eintrag ist jedoch immer noch "zufälliger" als viele der anderen gut bewerteten Antworten hier.

Trotzdem hast du es hier. Ermöglicht Wiederholungen von Zeichen und Unterstrichen:

Ruby, 77 Bytes

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

Ich habe auch putsanstelle von pin diesem verwendet, weil pdie Zeichenfolge in "Anführungszeichen" gedruckt und einige Zeichen mit einem Backslash maskiert werden.

Ruby, 70 Bytes

Wie Ventero betont, ~kann vor den Regexen übersprungen und printersetzt werden puts$_. Aber mit der hässlichen Ausgabe können Sie genauso gut alle abgelehnten Passwörter ausdrucken und sie zu einem Einzeiler zusammenfassen:

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

Erläuterung

Wie gewünscht. $_ist eine semi-magische Variable, die die letzte Zeile gelesen vom Eingang enthält - so dass Sie es nicht immer brauchen zu speichern, wie diese . Hier verwenden wir es jedoch wegen einer anderen Eigenschaft, nämlich dass der ~Operator einen regulären Ausdruck direkt darauf anwendet, ein Trick, den ich zuerst durch chron gelernt habe . Ich habe die Verwendung von ersetzt all, aber es sollte ziemlich einfach zu verstehen sein, wenn Sie den Rest bekommen ( siehe die Dokumentation ).

Java 8 - 354 329 319 275 267 Zeichen

Nur zum Spaß, mit Lambdas mit Java 8 - jede mögliche Ausgabe hat die gleiche Wahrscheinlichkeit, gefunden zu werden.

Dabei wird die Tatsache ausgenutzt, dass die zulässigen Zeichen fortlaufende ASCII-Codes von 33 bis 126 haben.

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

Beispielausgabe:

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

Komprimiertes Programm:

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

Python 2.X + 3.X (229 Zeichen): Generieren und ersetzen

Idee

1. Erstellen Sie zunächst eine Liste mit 15 zulässigen Symbolen
2. Ersetzen Sie eine zufällige Position rdurch eine zufällige Ziffer
3. Ersetzen Sie eine zufällige Position smit s != r, von einem Großbuchstaben
4. Gleiches für Kleinbuchstaben und Symbol wie in 2 und 3.

Code

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)

Python 2.X + 3.X (194 Zeichen): Generieren und prüfen

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)

• Danke an MvG , der mir das erzählt hat \uund \lin Python Regex nicht existiert.
• Vielen Dank an grc , der mir gesagt hat, dass random.sampledies ersatzlos ist.

Mit Fehler in der Problembeschreibung

Derzeit verlangt die Problembeschreibung nicht, dass jedes Symbol / jede Ziffer mit derselben Wahrscheinlichkeit erscheint. Mit der folgenden Lösung können Sie keine Annahme über ein einzelnes Symbol und / oder eine Position treffen. Aber Sie können es mit mehreren tun.

Python 2.X + 3.X (62 Zeichen)

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

Danke an daniero für die Idee sample zu verwenden.

Bash on * nix (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

Damit dies korrekt funktioniert, $adarf im Voraus kein gültiges, aber nicht zufälliges Kennwort festgelegt werden. Wenn Sie einschließen a=und eine Zeile voranstellen möchten, sind das drei weitere Zeichen, aber Sie können das Ding wiederholt ausführen. Sie können natürlich auch alle Zeilenumbrüche durch neue ersetzen, ;sodass Sie einen Einzeiler haben, den Sie so oft ausführen können, wie Sie möchten.

Darüber hinaus sollten Sie LC_ALL=C( LANGund LC_CTYPEinsbesondere) länderspezifische Umgebungsvariablen festgelegt oder nicht festgelegt haben , da die Zeichenbereiche davon abhängen, dass die Sortierreihenfolge der ASCII-Reihenfolge entspricht.

/dev/urandomist eine Quelle für zufällige Bytes. !-~ist der Bereich aller zulässigen Zeichen, wie in der Frage angegeben. tr -dcEntfernt alle Zeichen, die nicht im nächsten Argument aufgeführt sind. headNimmt 15 der verbleibenden Zeichen. grepprüft, ob jede der erforderlichen Arten mindestens einmal vorkommt. Die Eingabe besteht aus vier Kopien des Kandidaten. Die Reihenfolge der Symbole spielt also keine Rolle. Daher haben alle möglichen Passwörter eine Chance, ausgewählt zu werden. Das -qto grep unterdrückt die Ausgabe.

Aus unbekannten Gründen, /dev/randomanstatt /dev/urandomewig zu dauern. Es scheint, als wäre die Entropie ziemlich schnell erschöpft. Wenn Sie cdLust haben /dev, können Sie weitere Bytes vermeiden, aber das fühlt sich ein bisschen wie Schummeln an.

Python 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

Um den Code lesbar zu machen, habe ich nach der Schleife eine neue Zeile und einen Einzug eingefügt, die nicht erforderlich sind und die ich nicht gezählt habe.

Dies ist im Wesentlichen die gleiche Idee wie in der Bash-Version. Die zufällige Quelle ist hier random.sample, die Elemente nicht wiederholt. Um diesem Umstand entgegenzuwirken, verwenden wir 15 Exemplare der Liste der zulässigen Buchstaben. Auf diese Weise kann jede Kombination auftreten, auch wenn solche mit wiederholten Buchstaben seltener vorkommen. Aber ich entscheide mich, dies als Feature und nicht als Bug zu betrachten, da die Frage nicht für alle Permutationen die gleiche Wahrscheinlichkeit erforderte, sondern nur die Möglichkeit.

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

Eine neue Zeile und ein neuer Einzug werden nicht gezählt. Abgesehen von etwas Python-3-spezifischem Syntax-Overhead ist dies die gleiche Lösung wie für Python 2.

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

Ich habe die Zeilenumbrüche zur besseren Lesbarkeit hinzugefügt, aber nicht gezählt.

R (114)

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

Zeilenumbruch und Einrückung in der Schleife hinzugefügt, aber nicht gezählt. Wenn Sie Lust dazu haben, können Sie dies wieder in eine einzelne ;Zeile verschieben.

C # ( 123 - 139 103 - 127 Zeichen komprimiert):

Verwendung einer vollkommen adäquaten Framework-Methode in System.Web.dll:

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

Verdichtet:

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

Beispiel:

b+m2ae0K:{dz7:A

Alternativ können Sie den Wert des zweiten Parameters ( int numberOfNonAlphanumericCharacters) von der Befehlszeile übernehmen:

class P
{
    static void Main(string[] a)
    {
        Console.WriteLine(System.Web.Security.Membership.GeneratePassword(15, int.Parse(a[0])));
    }
}

R (301 322 Zeichen)

Korrektur vergessen, nach Ziffern zu suchen.

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

(Leerzeichen nur zur Verdeutlichung hinzugefügt).

Erzeugt alle möglichen 15-Zeichen-Permutationen der 94 Zeichen. Wählen Sie dann eine zufällig aus, bis sie den Kriterien entspricht.

Die Magie liegt in der q:qOperation, die einen neuen Faktordatentyp erzeugt, der die Wechselwirkung aller Faktoren in der ersten qListe mit allen Faktoren in der zweiten Liste darstellt , wobei jede mögliche Kombination dieser beiden Listen in der Liste von "" enthalten ist. Ebenen "dieses Faktors. Interagieren Sie 15 Kopien der Liste der zulässigen Zeichen, und Sie erhalten (94 ^ 15) mögliche Ebenen.

Bitte versuchen Sie dies nicht zu Hause. Es dauert ein paar Sekunden, bis der Code alle drei Permutationen ermittelt hat. Ich kann mir wirklich nicht vorstellen, wie lange es dauern würde, bis alle 15 Permutationen ermittelt sind, wenn auf Ihrem Computer nicht einfach der Speicher im Speicher ausgeht inzwischen. Als ich das fertige (dreistellige Passwort) Skript ausführte, um es zu überprüfen, war das erste Passwort, das es ausspuckte, "oO =", was meiner Meinung nach die Reaktion zusammenfasst, die Sie auf diesen Code haben sollten.

Mathematica 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]

Beispiele

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

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

Golfscript (60)

Da die Obl. golfscript fehlt und als noob brauche ich sowieso die übung :)

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

Es wird lediglich ein Array mit den 4 erforderlichen + 11 zufälligen Zeichen erstellt und in zufälliger Reihenfolge sortiert.

JavaScript 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(""))

Verwenden einer Regel, bei der:

function(x){return x*x}kann umgeschrieben werden als function(x)x*x. Scheint nur für Funktionen zu funktionieren, die einen Wert zurückgeben.

Nächste Iteration, reduziert x.sort(function().5-R())aufx.sort(y=>.5-R())

Nächste Iteration, weiter reduziert mit fetter Pfeilnotation, die leider nur für Firefox 22 und höher funktioniert.

JavaScript (269 Zeichen komprimiert)

Aus Gründen der Übersichtlichkeit ist dies der Code, bevor ich ihn in JS-Fiddle komprimiert habe :

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

Hier ist es auf 269 Zeichen komprimiert ( JS-Fiddle davon ):

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

Clojure (63):

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

Es muss jedoch verbessert werden, um sicherzustellen, dass mindestens 1 Zeichen jeder Kategorie (Oberes, Unteres, Ziffer, Symbol) enthalten ist.

In SQL-Server

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)

Sehen Sie es in Aktion - 1

sehen Sie es in Aktion - 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=

Kommentiert / eingerückt:

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

PowerShell: 119

Gofled Code

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

Nicht golfen und kommentiert

# 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

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

Besser lesbar (und nicht ausführbar) geschrieben;

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

Ziemlich unkompliziert und überraschenderweise nicht viel länger als eine "Generiere, versuche es erneut bei einem Match-Fehler" -Version.

PSQL (189)

Fühlt sich an wie PSQL ist ein bisschen wortreich ... :)

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 Demo .

PHP, 235 225

Dieses Skript mischt die Zeichen und überprüft dann über RegEx, ob das Kennwort sicher ist (oder neu generiert wird).

<?php
while(!preg_match('/^(?=.*[A-Z])(?=.*[^A-Za-z])(?=.*[0-9])(?=.*[a-z]).{15}$/',$p)){ $p = substr(str_shuffle('ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789`~!@#$%^&*()_+-={}|[]\:";\'<>?,./'),0,15); }
echo $p;

Javascript (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(''))

Semi-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(''))

Perl, 92

Nicht so prägnant wie die Ruby-Antwort, aber ich bin sicher, dass ein Perl-Assistent dies noch kürzer machen könnte ... Ich bin mit all den m//s am Ende nicht allzu glücklich , scheint aber zu funktionieren und sollte die Bedingungen erfüllen, um schließlich zu generieren alle Permutationen.

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

Beispielnutzung:

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

Bearbeitet, um die Validierung [[:punct:]]zu [\W_]korrigieren und nach MvG-Kommentaren zu wechseln.

Java 7 ( 270 234 Zeichen)

Die Voraussetzung ist die gleiche, die von @assylias mit Java 8 verwendet wird (generieren Sie zufällige Passwörter, bis ein gültiges Passwort vorliegt). Anstatt Lambdas zu verwenden, wird das Kennwort jedoch durch Iteration eines char-Arrays generiert und durch Abgleichen eines regulären Ausdrucks überprüft.

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

Minimierter Code:

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

Power Shell

One Liner Version (143 Bytes)

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

Mini-Version (146 Bytes)

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

Lesbare Version (860 Bytes)

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
}

Wir danken Iszi für verschiedene Tipps zur Verkürzung des Codes.

Faktor 196 Zeichen

Gleicher Algorithmus wie bei MvG und Elch. Es ist nicht das kürzeste, sollte aber alle (aktuellen) Kriterien in der Frage erfüllen:

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

C - 154 Zeichen

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

Wie ich hasse srand()? Lass mich die Wege zählen.

Haskell, 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

Die gedruckte Zeichenfolge ist in Anführungszeichen gesetzt und enthält keine umgekehrten Schrägstriche und Anführungszeichen. Wenn das nicht akzeptabel ist, printkann es durch putStrLn3 weitere Bytes ersetzt werden. Hier ist eine besser lesbare Version:

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']
    , "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~"
    ]

Es ist ganz einfach, es erstellt nur eine unendliche / träge Liste von zufälligen ASCII-Zeichen im Bereich '!'bis '~'und wirft dann das erste Element aus, bis die ersten 15 Zeichen mindestens ein Zeichen aus jeder Zeichenfolge der erforderlichen Zeichen enthalten.

Excel VBA, 209 Bytes

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

Generiert zufällig 15 ASCII-Zeichen, sodass alle möglichen Kombinationen möglich sind. Verwendet dann ein Muster mit regulären Ausdrücken, um zu überprüfen, ob es mindestens eines der einzelnen Kriterien enthält.

Wenn dies der Fall ist, wird das Passwort angezeigt, wenn dies nicht der Fall ist, wird "Redo" angezeigt.

Wir danken Bart Kiers für das Muster des regulären Ausdrucks: https://stackoverflow.com/questions/1559751/regex-to-make-sure-dass-der-String- mindestens-niedrigere- Fallzeichen- enthält Oberer, höher

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

Verwenden - Führen Sie einfach das Skript aus

Python (121 Zeichen)

Nutzt die Tatsache, dass Sie Listen in Python multiplizieren können [1,2,3] * 2 ergibt [1,2,3,1,2,3]. Importiert zufällig. Zahlen in einer Liste, multipliziert mit drei, sind Grenzen zwischen Bereichen in der ASCII-Tabelle für benötigte Zeichen, z. B. [65, 90] Maps für Großbuchstaben.

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

PHP 5.5 (230 Bytes)

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

Oder in einer Zeile (211 Bytes)

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