Сервер домена требует, чтобы все сотрудники имели надежный случайный пароль, соответствующий следующим правилам:

• Ровно 15 символов.
• Только вводимые с клавиатуры символы (как показано в коде типа ниже). Обучение продажам использовать коды ALT + NUMPAD не допускается.
• Как минимум 1 строчная буква: abcdefghijklmnopqrstuvwxyz
• Как минимум 1 заглавная буква: ABCDEFGHIJKLMNOPQRSTUVWXYZ
• Минимум 1 цифра: 0123456789
• Как минимум 1 символ: `~!@#$%^&*()_+-={}|[]\:";'<>?,./

Для этого ИТ-отдел поручил и будет распространять генератор случайных паролей среди всех сотрудников. Все сотрудники должны будут использовать генератор случайных паролей. Требования к генератору случайных паролей, в дополнение к ограничениям пароля выше:

• Он должен быть в состоянии генерировать все перестановки всех допустимых символов.
• Он должен отображать сгенерированный пароль на экране.
• Код должен быть как можно меньше (в байтах).

Пожалуйста, отправьте предложенное решение в течение следующей недели.

Математика (18)

Позвольте мне немного обмануть

= 15char ASCII pwd

&(^F7yP8k:*1P<t

PS не безопасность :)

Рубин, 74 69 байт

Просто случайный выбор из диапазона ASCII 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 байт

Как указывает Ventero, ~может быть пропущен перед регулярными выражениями и printможет быть заменен puts$_. Но с ужасным выводом это может привести к тому, что вы также можете распечатать все отклоненные пароли, сжав их в одну строку:

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

объяснение

Как просили. $_это полумагическая переменная, которая содержит последнюю строку, прочитанную из ввода - так что вам не всегда нужно ее хранить, как это . Здесь, однако, мы используем его из-за другого свойства, а именно, что ~оператор применяет регулярное выражение непосредственно к нему, трюк, который я впервые узнал с помощью chron . Я заменил использование all, но это должно быть довольно легко понять, если вы получите остальное ( см. Документы ).

Java 8 - 354 329 319 275 267 символов

Просто для удовольствия, используя лямбды с Java 8 - каждый возможный вывод имеет одинаковую вероятность быть найденным.

Он использует тот факт, что разрешенные символы имеют последовательные коды ASCII, от 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);}}

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

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

• Спасибо MvG, который сказал мне это \uи\l не существует в регулярных выражениях Python.
• Спасибо grc, который сказал мне, что random.sampleэто без замены, чтобы получить все возможные разрешенные пароли, нам нужна выборка с заменой.

Использование недостатка в описании проблемы

В настоящее время описание проблемы не требует, чтобы каждый символ / цифра появлялся с одинаковой вероятностью. С помощью следующего решения вы не можете делать какие-либо предположения об одном символе и / или позиции. Но вы можете сделать это с несколькими.

Python 2.X + 3.X (62 символа)

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

Спасибо Даниеро за идею использовать образец.

Bash на * 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

Для правильной работы $aне должен быть установлен действительный, но неслучайный пароль заранее. Если вы хотите включить a=и разрыв строки вперед, это еще три символа, но это позволяет вам запускать эту вещь несколько раз. Вы также можете заменить все новые строки на; чтобы у вас была однострочная которую вы можете выполнять так часто, как пожелаете.

Кроме того, вы должны были установить LC_ALL=Cили не устанавливать какие-либо переменные среды, зависящие от локали ( LANGиLC_CTYPE зависящие от в частности), поскольку диапазоны символов зависят от порядка сопоставления, равного порядку ascii.

/dev/urandomявляется источником случайных байтов. !-~это диапазон всех допустимых символов, как указано в вопросе. tr -dcудаляет все символы, не перечисленные в следующем аргументе. headзанимает 15 из оставшихся символов. grepпроверяет, встречается ли каждый из требуемых видов хотя бы один раз. Его ввод состоит из четырех копий кандидата, поэтому порядок символов не имеет значения, поэтому все возможные пароли имеют шанс быть выбранными. -qК ГРЭП выход подавляет.

По неизвестным причинам, /dev/randomа не /dev/urandomпринимает возраст. Кажется, энтропия довольно быстро исчерпала себя. Если вы cdв/dev , вы можете избежать еще несколько байт, но чувствует себя немного как обман.

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

Чтобы сделать код читабельным, я добавил новую строку и отступ после цикла, который не является необходимым и который я не учел.

По сути, это та же идея, что и в версии bash. Случайный источник здесь 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)

Один перевод строки и один отступ снова не учитываются. Помимо некоторых накладных расходов на синтаксис, специфичных для Python-3, это то же решение, что и для 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)

Я добавил новые строки для удобства чтения, но не посчитал их.

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

Разрыв строки и отступ внутри цикла добавлены, но не учитываются. Если вам это нравится, вы можете снова переместить это в одну ;строку.

C # ( сжатые 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])));
    }
}

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

(пробелы добавлены только для ясности).

Создает все возможные 15-символьные перестановки из 94 символов. Затем случайным образом выбирает один, пока не будет соответствовать критериям.

Волшебство в q:qоперации, которая генерирует новый тип данных фактора, который является взаимодействием всех факторов в первом qсписке со всеми факторами во втором списке , с каждой возможной комбинацией этих двух списков, включенных в список " уровни "этого фактора. Взаимодействуйте 15 копий списка разрешенных персонажей, и вы получите (94 ^ 15) возможных уровней.

Пожалуйста, не пытайтесь сделать это дома. Код занимает пару секунд, чтобы выяснить все трехсимвольные перестановки, я действительно не могу себе представить, сколько времени потребуется, чтобы выяснить все 15-символьные перестановки, если ваш компьютер не просто не хватает памяти в То время. Когда я запустил готовый скрипт (трехсимвольный пароль), чтобы проверить его, первым выдаваемым им паролем был «oO =», который, я думаю, подводит итог реакции, которую вы должны иметь на этот код.

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]

Примеры

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

Гольфскрипт (60)

Так как обл. Гольфскрипт отсутствует, и как нуб мне все равно нужна практика :)

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

Он просто строит массив из 4 обязательных + 11 случайных символов и сортирует их в случайном порядке.

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

Используя правило, где:

function(x){return x*x}может быть переписан как function(x)x*x. Кажется, работает только для функций, возвращающих значение.

Следующая итерация, уменьшенная x.sort(function().5-R())доx.sort(y=>.5-R())

Следующая итерация уменьшена с помощью жирной стрелки, что, к сожалению, работает только для Firefox 22 и выше.

JavaScript (сжато 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 символов ( JS-Fiddle of it ):

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

Но необходимо улучшить, чтобы убедиться, что он содержит не менее 1 символа каждой категории (верхний, нижний, цифра, символ).

В 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

САС (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;

PowerShell: 119

Позолоченный код

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

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

Записано более читаемым (а не исполняемым) способом;

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

Довольно прямолинейно и на удивление не намного дольше, чем версия «создать, повторить при сбое матча».

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

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;

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

Пол-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

Не так лаконично, как ответ на Ruby, но я уверен, что мастер Perl мог бы сделать это еще короче ... Я не слишком доволен всеми 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 комментариев.

Java 7 ( 270 234 символов)

Посылка та же самая, что используется @assylias с java 8 (генерируйте случайные пароли до тех пор, пока не получите действительный пароль). Однако вместо использования лямбда-символов пароль генерируется путем итерации массива char и проверяется путем сопоставления с регулярным выражением.

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

Powershell

Версия с одним вкладышем (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
}

Благодарим Исзи за различные советы по сокращению кода.

Фактор, 196 символов

Тот же алгоритм, что и в MvG и Moose's. Это не самый короткий, но должен соответствовать всем (текущим) критериям в вопросе:

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 символа

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()? Позвольте мне сосчитать пути.

Хаскелл, 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

Напечатанная строка имеет кавычки и экранирует символы обратной косой черты и кавычки; если это неприемлемо, printможно заменить еще putStrLnна 3 байта. Вот более читаемая версия:

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 символов не получат хотя бы один символ из каждой строки обязательных символов.

Excel 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-least-one-lower-case-char- верхний

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
}

Использование - Просто запустите скрипт

Python (121 символ)

Использует тот факт, что вы можете умножать списки в Python [1,2,3] * 2, дает [1,2,3,1,2,3]. Импорт случайный. Числа в списке, умноженные на три, являются границами между диапазонами в таблице ascii для необходимых символов, например, [65, 90] отображаются в верхний регистр букв.

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 байт)

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