O servidor de domínio exige que todos os funcionários tenham uma senha forte e aleatória, em conformidade com as seguintes regras:

• Exatamente 15 caracteres.
• Apenas caracteres digitáveis ​​pelo teclado (conforme mostrado no tipo de código abaixo). Ensinar as vendas a usar os códigos ALT + NUMPAD não é permitido.
• Pelo menos 1 letra minúscula: abcdefghijklmnopqrstuvwxyz
• Pelo menos 1 letra maiúscula: ABCDEFGHIJKLMNOPQRSTUVWXYZ
• Pelo menos 1 dígito numérico: 0123456789
• Pelo menos 1 símbolo: `~!@#$%^&*()_+-={}|[]\:";'<>?,./

Para esse fim, a TI encomendou e distribuirá um Gerador de senha aleatória a todos os funcionários. Todos os funcionários deverão usar o Gerador de senha aleatória. Os requisitos para o Gerador de senha aleatória são, além das restrições de senha acima:

• Ele deve ser capaz de gerar todas as permutações de todos os caracteres permitidos.
• Ele deve exibir a senha gerada na tela.
• É necessário que o código seja o menor possível (em bytes).

Envie sua solução proposta dentro da próxima semana.

Mathematica (18)

Deixe-me um pouco de trapaça

= 15char ASCII pwd

&(^F7yP8k:*1P<t

PS não segurança :)

Ruby, 74 69 bytes

Faça uma amostra aleatória do intervalo de ascii 33 - 126 até que todas as classes de caracteres estejam presentes:

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

Ruby, 39 bytes

Usando a descoberta inteligente de alce:

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

Observe que as regras foram alteradas depois que eu publiquei isso pela primeira vez. No momento, as duas entradas anteriores se aplicavam às regras. Gostaria também de salientar que as regras ainda não estão muito bem definidas:

(..) todas as permutações de todos os caracteres permitidos

"Permutações". Não há permutações dos caracteres permitidos que estejam em conformidade com o restante das regras, porque qualquer permutação do conjunto de caracteres permitidos é tão longa quanto o próprio conjunto de caracteres permitidos (enquanto a senha deve ter 15 caracteres). E não há repetições em uma permutação. No entanto, minha primeira entrada é ainda mais "aleatória" do que muitas das outras respostas bem votadas aqui.

No entanto, aqui está. Permite repetições de caracteres e sublinhado:

Ruby, 77 bytes

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

Eu também usei no putslugar pdeste porque pimprime a cadeia de caracteres entre "aspas" e alguns caracteres escapam com uma barra invertida.

Ruby, 70 bytes

Como Ventero aponta, ~pode ser pulado na frente dos regexes e printpode ser substituído puts$_. Mas com a saída feia, isso faz com que você também possa imprimir todas as senhas rejeitadas, comprimindo-as em uma única linha:

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

Explicação

Como pedido. $_é uma variável semi-mágico que contém a última linha ler da entrada - para que você não precisa sempre de armazená-lo, como este . Aqui, porém, a usamos por causa de outra propriedade, a saber, que o ~operador aplica uma regex diretamente a ela, um truque que aprendi pela primeira vez por chron . Substituí o uso de all, mas deve ser bem fácil entender se você tem o restante ( consulte os documentos ).

Java 8 - 354 329 319 275 267 caracteres

Apenas por diversão, usando lambdas com Java 8 - cada saída possível tem a mesma probabilidade de ser encontrada.

Ele usa o fato de que os caracteres permitidos têm códigos ASCII consecutivos, de 33 a 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);
    }
}

Saída de amostra:

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

Programa compactado:

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 caracteres): gere e substitua

Idéia

1. Primeiro faça uma lista com 15 símbolos permitidos
2. Substitua uma posição aleatória rpor um dígito aleatório
3. Substituir uma posição aleatória s, com s != r, por uma letra maiúscula
4. O mesmo para letra minúscula e símbolo como em 2 e 3.

Código

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 caracteres): Gere e verifique

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)

• Obrigado ao MvG, que me disse isso \ue \lnão existe no regex do Python.
• Graças ao grc, que me disse que random.sampleé sem substituição, seja para obter todas as senhas permitidas possíveis, precisamos de amostragem com substituição.

Usando falha na descrição do problema

Atualmente, a descrição do problema não exige que todos os símbolos / dígitos apareçam com a mesma probabilidade. Com a solução a seguir, você não pode fazer nenhuma suposição sobre um único símbolo e / ou posição. Mas você pode fazer isso com vários.

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

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

Agradeço a daniero pela ideia de usar a amostra.

Bash em * 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

Para funcionar corretamente, $anão deve ser definido com uma senha válida, mas não aleatória, com antecedência. Se você deseja incluir a=e uma quebra de linha na frente, são mais três caracteres, mas permite executar a coisa repetidamente. Obviamente, você também pode substituir todas as novas linhas ;por uma única linha que possa ser executada quantas vezes desejar.

Além disso, você deve definir LC_ALL=Cou não variáveis ​​de ambiente específicas do código do idioma ( LANGe LC_CTYPEem particular), pois os intervalos de caracteres dependem da ordem de intercalação igual à ordem ascii.

/dev/urandomé a fonte de bytes aleatórios. !-~é o intervalo de todos os caracteres permitidos, conforme especificado na pergunta. tr -dcremove todos os caracteres não listados em seu próximo argumento. headleva 15 dos caracteres restantes. grepverifica se cada um dos tipos necessários ocorre pelo menos uma vez. Sua entrada consiste em quatro cópias do candidato; portanto, a ordem dos símbolos não importa; portanto, todas as senhas possíveis têm chance de serem selecionadas. O -qto grep suprime a saída.

Por razões desconhecidas, em /dev/randomvez de /dev/urandomlevar idades. Parece que a entropia se esgotou muito rapidamente. Se você cdpara /dev, você pode evitar mais alguns bytes, mas que se sente um pouco como fazer batota.

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

Para tornar o código legível, adicionei uma nova linha e recuo após o loop, que não é necessário e que não contei.

Esta é essencialmente a mesma ideia que na versão bash. A fonte aleatória aqui é random.sample, que não repetirá elementos. Para combater esse fato, usamos 15 cópias da lista de cartas permitidas. Dessa forma, todas as combinações ainda podem ocorrer, embora aquelas com letras repetidas ocorram com menos frequência. Mas decido considerar isso um recurso, não um bug, já que a pergunta não exigia igual probabilidade para todas as permutações, apenas a possibilidade.

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)

Uma nova linha e um recuo novamente não são contados. Além de algumas sobrecargas de sintaxe específicas do Python-3, esta é a mesma solução do 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)

Eu adicionei as novas linhas para facilitar a leitura, mas não as contei.

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

Quebra de linha e recuo dentro do loop foram adicionados, mas não contados. Se quiser, você pode movê-lo novamente para uma ;linha separada.

C # ( 123 - 139 103 - 127 caracteres compactados):

Usando um método de estrutura perfeitamente adequado em System.Web.dll:

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

Compactado:

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

Exemplo:

b+m2ae0K:{dz7:A

Como alternativa, pegue o valor do segundo parâmetro ( int numberOfNonAlphanumericCharacters) na linha de comando:

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

R (301 322 caracteres)

A correção esqueceu de verificar os dígitos.

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

(espaço em branco adicionado apenas para maior clareza).

Gera todas as permutações possíveis de 15 caracteres dos 94 caracteres. Em seguida, seleciona aleatoriamente um até que corresponda aos critérios.

A mágica está na q:qoperação, que gera um novo tipo de dado de fator que é a interação de todos os fatores da primeira qlista com todos os fatores da segunda lista , com todas as combinações possíveis dessas duas listas incluídas na lista de " níveis "desse fator. Interaja 15 cópias da lista de caracteres permitidos e você obtém (94 ^ 15) níveis possíveis.

Por favor não tente isto em casa. O código leva alguns segundos para descobrir todas as permutações de três caracteres. Realmente não consigo imaginar quanto tempo levaria para descobrir todas as permutações de 15 caracteres, se o computador não tivesse apenas memória insuficiente no enquanto isso. Quando executei o script finalizado (senha de três caracteres) para verificá-lo, a primeira senha que ele cuspiu foi "oO =", que eu penso resume a reação que você deve ter com esse código.

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]

Exemplos

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

Golfe (60)

Desde o obl. golfscript está faltando e como um noob eu preciso da prática de qualquer maneira :)

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

Ele apenas cria uma matriz com os 4 caracteres aleatórios necessários + 11 e ordena em ordem aleatória.

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

Usando uma regra em que:

function(x){return x*x}pode ser reescrito como function(x)x*x. Apenas parece funcionar para funções que retornam um valor.

Próxima iteração, reduzida x.sort(function().5-R())parax.sort(y=>.5-R())

Próxima iteração, reduzida ainda mais com a notação de seta gorda, que infelizmente só funciona para o Firefox 22 e superior.

JavaScript (269 caracteres compactados)

Para maior clareza, este é o código antes de compactá-lo no 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("");

Aqui, ele é compactado em 269 caracteres ( JS-Fiddle ):

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

Mas precisa ser aprimorado para garantir que contenha pelo menos 1 caractere de cada categoria (Superior, Inferior, Dígito, Símbolo).

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

Veja em ação - 1

veja em Ação - 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=

Comentado / recuado:

%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

Código Gofled

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

Sem golfe e comentado

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

Escrito de maneira mais legível (e não executável);

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

Bastante direto e surpreendentemente não muito mais do que uma versão "gerar, tentar novamente ao falhar na correspondência".

PSQL (189)

Parece que o PSQL é um pouco detalhado ... :)

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

Demonstração do SQLfiddle .

PHP, 235 225

Esse script embaralha os caracteres e é verificado via RegEx para garantir que a senha seja forte (ou seja regenerada).

<?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-não-destruído;

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

Não é tão conciso quanto a resposta do Ruby, mas tenho certeza de que um assistente de Perl poderia tornar isso ainda mais curto ... Não estou muito feliz com todos os m//s no final, mas parece funcionar e deve satisfazer as condições para eventualmente gerar todas as permutações.

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

Uso da amostra:

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

Editado para corrigir a validação e mudar [[:punct:]]para [\W_]após os comentários dos MvGs.

Java 7 ( 270 234 caracteres)

A premissa é a mesma usada por @assylias com java 8 (gerar senhas aleatórias até uma senha válida). No entanto, em vez de usar lambdas, a senha é gerada iterando uma matriz char e validada pela correspondência de uma regex.

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

Código Minificado:

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

Powershell

Versão One Liner (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 versão (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

Versão legível (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
}

Agradecemos a Iszi por várias dicas para encurtar o código.

Fator, 196 caracteres

Mesmo algoritmo que MvG e moose. Não é o mais curto, mas deve atender a todos os critérios (atuais) da pergunta:

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 caracteres

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

Como odeio srand()? Deixe-me contar os caminhos.

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

A sequência impressa possui aspas e escapa os caracteres de barra invertida e de aspas; se isso for inaceitável, printpode ser substituído putStrLnpor mais 3 bytes. Aqui está uma versão mais legível:

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

É bem simples, apenas cria uma lista infinita / lenta de caracteres ASCII aleatórios no intervalo '!'para '~', em seguida, lança o primeiro elemento até que os 15 primeiros caracteres tenham pelo menos um caractere de cada sequência de caracteres necessários.

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

Gera aleatoriamente 15 caracteres ASCII para que todas as combinações possíveis sejam possíveis. Em seguida, usa um padrão de expressão regular para verificar se ele contém pelo menos um de cada critério.

Se isso acontecer, a senha será exibida, se não "refazer" será exibido.

Agradecemos a Bart Kiers pelo padrão Expressão Regular: https://stackoverflow.com/questions/1559751/regex-to-make-sure-that-the-string-contains-at-least-one-lower-case-char- superior

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
}

Usando - Basta executar o script

Python (121 caracteres)

Faz uso do fato de que você pode multiplicar listas em Python [1,2,3] * 2 fornece [1,2,3,1,2,3]. Importa aleatoriamente. Os números em uma lista multiplicada por três são bordas entre os intervalos na tabela ascii para os caracteres necessários, por exemplo, [65, 90] mapeia para letras maiúsculas.

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

Ou em uma linha (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)));