域服务器要求所有员工都具有严格的随机密码，并遵守以下规则：

• 恰好15个字符。
• 只能由键盘输入的字符（如下面的代码类型所示）。禁止教销售人员使用ALT + NUMPAD代码。
• 至少1个小写字母： abcdefghijklmnopqrstuvwxyz
• 至少1个大写字母： ABCDEFGHIJKLMNOPQRSTUVWXYZ
• 至少1个数字： 0123456789
• 至少1个符号： `~!@#$%^&*()_+-={}|[]\:";'<>?,./

为此，IT已委托并将将“随机密码生成器”分发给所有员工。所有员工都必须使用随机密码生成器。除了上述密码限制之外，Random Password Generator的要求还包括：

• 它必须能够生成所有允许字符的所有排列。
• 它必须在屏幕上显示生成的密码。
• 要求代码尽可能小（以字节为单位）。

请在下周内提交您建议的解决方案。

Mathematica（18）

让我作弊

= 15char ASCII pwd

&(^F7yP8k:*1P<t

PS不安全:)

Ruby，74个 69字节

只需从ascii范围33-126随机采样，直到出现所有类别的字符：

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

Ruby，39个字节

使用驼鹿的聪明发现：

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

请注意，在我第一次发布此规则后，规则发生了变化。当时，先前的两个条目都适用于规则。我还想指出，规则的定义还不是很清楚：

（..）所有允许字符的所有排列

“排列”。有没有 排列与规则中其余的规定，因为该组允许任何字符排列是，只要一套允许的字符本身（而密码应该是15个字符）允许的字符。并且在排列中没有重复。但是，我的第一个条目仍然比此处的其他许多受好评的答案更“随机”。

不过，这里有。允许重复字符和下划线：

Ruby，77个字节

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

我还用puts了它p，因为它p打印出了用引号引起来的字符串，并且某些字符以反斜杠转义了。

Ruby，70个字节

正如Ventero所指出的，~可以在正则表达式前面跳过，并print可以替换puts$_。但是，由于输出丑陋，因此您也可能还会打印所有被拒绝的密码，并将其压缩为单行：

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

说明

按照要求。$_是半魔术变量，包含从输入读取的最后一行-因此，您不必总是像这样存储它。但是在这里我们由于另一个属性而使用它，即~运算符直接将正则表达式应用到它，这是我由chron第一次学习的技巧。我替换了的用法all，但是如果您得到其余的内容，则应该很容易理解（请参阅docs）。

Java 8-354 329 319 275 267个字符

只是为了好玩，将lambda与Java 8配合使用-每个可能的输出都有被发现的相同可能性。

它使用以下事实：允许的字符具有从33到126的连续ascii码。

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

感谢daniero提出使用示例的想法。

在* 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到grep来禁止输出。

由于未知的原因，/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个允许的信件清单。这样，每种组合仍然可以发生，尽管带有重复字母的组合出现的频率会降低。但是我决定考虑将此功能作为功能，而不是错误，因为问题并不需要所有排列的均等概率，而仅是可能性。

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)

一个换行符和一个缩进再次不计算在内。除了某些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])));
    }
}

R（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个字符的排列将花费多长时间。与此同时。当我运行完成的（三个字符的密码）脚本进行检查时，它吐出的第一个密码是“ 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)

Golfscript（60）

自从obl。golfscript不见了，作为菜鸟，我还是需要练习:)

[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）：

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

在Action--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;

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演示。

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

半脱胶

// 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//s 都不是很满意，但是似乎可以工作并且应该满足最终生成的条件所有排列。

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'

编辑以修正验证并在MvG注释后更改[[:punct:]]为[\W_]。

Java 7的（270 234个字符）

前提与@assylias在Java 8中使用的前提相同（生成随机密码直到有效密码）。但是，不是使用lambda，而是通过迭代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);}}

电源外壳

一个Liner版本（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
}

感谢Iszi提供各种缩短代码的技巧。

因子196个字符

与MvG和驼鹿算法相同。它不是最短的，但应满足问题中的所有（当前）条件：

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则可以用putStrLn3个以上的字节替换。这是一个更具可读性的版本：

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随机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字符，因此所有可能的组合都是可能的。然后使用正则表达式模式检查其是否包含每个条件中的至少一个。

如果是，则显示密码，否则显示“ redo”。

感谢Bart Kiers的正则表达式模式：https : //stackoverflow.com/questions/1559751/regex-to-make-sure-that-the-string-contains-at-least-one-lower-case-char-上

自动热键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]。随机导入。列表中的数字乘以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)));