关于系列

首先，您可以像对待其他任何代码高尔夫挑战赛一样对待它，并回答它，而无需担心系列赛。但是，在所有挑战中都有排行榜。您可以在第一篇文章中找到排行榜以及有关该系列的更多信息。

尽管我对该系列有很多想法，但是未来的挑战还没有定下来。如果您有任何建议，请在相关的沙箱帖子上让我知道。

漏洞2：来自正态分布的数字

我不敢相信这还没有完成！您将根据正态分布生成随机数。一些规则（大多数提交可能会自动覆盖其中的大多数规则，但其中一些规则已经到位，以确保多种语言之间的结果一致）：

• 您应该将两个非负整数用作输入：种子S和N要返回的数字量。输出应该是N从均值0和方差1的正态分布中得出的浮点数列表。只要您提交的文件具有相同的种子，S它就会产生相同的编号。特别地，如果它被称为一次与次，用中，第一两个输出中的条目应该是相同的。另外，至少2 ^16个不同的值应产生不同的序列。(S, N1)(S, N2)min(N1, N2)S

• 您可以使用任何记录在案的内置随机数生成器，从（近似）均匀分布中提取数字，前提是您可以S继续使用它，并且它支持至少2 ¹⁶种不同的种子。如果这样做，RNG应该能够为您从中请求的任何给定数字返回至少2 ^20个不同的值。

• 如果您的可用统一的RNG有一个较小的范围内，是不是seedable，或支持太少种子，您必须先建立一个统一的RNG具有足够大的范围上的顶部内置一个或您必须实现自己的合适的RNG使用种子。此页面可能对此有所帮助。
• 如果您没有实现生成正态分布的既定算法，请提供正确性证明。无论哪种情况，您选择的算法都必须产生理论上精确的正态分布（除非存在基础PRNG或有限精度数据类型的限制）。
• 您的实现应使用并返回浮点数（至少32位宽）或定点数（至少24位宽），并且所有算术运算都应使用所选类型的全部宽度。
• 您不得使用任何与正态分布或高斯积分直接相关的内置函数，例如误差函数或其反函数。

您可以编写完整的程序或函数，并通过STDIN，命令行参数，函数参数或提示接受输入，并通过返回值或通过打印到STDOUT（或最接近的替代方法）产生输出。

S并且N将是非负整数，每个整数均小于2 ²⁰。输出可以采用任何方便，明确的列表或字符串格式。

这是代码高尔夫球，因此最短的提交（以字节为单位）获胜。当然，每位用户最短的提交时间也将进入该系列的整体排行榜。

排行榜

该系列的第一篇文章将产生一个排行榜。

为确保您的答案显示出来，请使用以下Markdown模板以标题开头每个答案：

# Language Name, N bytes

N您提交的文件大小在哪里。如果您提高了分数，可以将旧分数保留在标题中，方法是将它们打掉。例如：

# Ruby, <s>104</s> <s>101</s> 96 bytes

（目前未显示该语言，但是该代码段确实需要并对其进行解析，并且将来我可能会添加一个语言排行榜。）

Dyalog APL，33个字节

{(.5*⍨¯2×⍟?0)×1○○2×?0}¨⍳⎕⊣⎕rl←1+⎕

Box-Muller：

⎕         ⍝ evaluated input
⎕rl←1+⎕   ⍝ set APL's random seed to 1+⎕ (S)
          ⍝   add 1 because ⎕rl←0 has special meaning: sets the seed randomly
{ }¨⍳N    ⍝ do the thing in braces N times
?0        ⍝ random number 0≤x<1
1○○2×A    ⍝ sin(2πA)
.5*⍨¯2×⍟B ⍝ sqrt(-2lnB)

R，68字节

function(S,N){set.seed(S);sqrt(-2*log(runif(N)))*cos(2*pi*runif(N))}

这使用了runif()从统一分布中产生随机偏差的函数。使用来指定用于生成随机数的种子，该种子set.seed()默认情况下使用Mersenne-Twister算法，周期为2 ^ 19937-1。

结果是长度为N的R向量，其中包含计算出的标准法线偏差。

这使用Box-Muller方法：对于两个独立的统一随机变量U和V，

Dyalog APL，42 34

{⎕RL←⍺⋄{(.5*⍨¯2×⍟⍺)×1○⍵×○2}/?⍵2⍴0}

此函数S以其左参数和N右参数为参数。

     5{⎕RL←⍺⋄{(.5*⍨¯2×⍟⍺)×1○⍵×○2}/?⍵2⍴0}10
3.019132549 ¯0.2903143175 ¯0.7353414637 1.421417015 2.327544764 ¯0.00005019747711 ¯0.9582127248 ¯0.2764568462
      ¯0.1602736853 ¯0.9912352616
     5{⎕RL←⍺⋄{(.5*⍨¯2×⍟⍺)×1○⍵×○2}/?⍵2⍴0}20
3.019132549 ¯0.2903143175 ¯0.7353414637 1.421417015 2.327544764 ¯0.00005019747711 ¯0.9582127248 ¯0.2764568462
      ¯0.1602736853 ¯0.9912352616 0.642585109 ¯0.2450019151 ¯0.415034463 0.03481768503 ¯0.4621212815 ¯0.760925979
      0.2592913013 1.884867889 ¯0.9621252731 0.3062560446

它是Box-Muller变换的一种实现，使用Dyalog APL的内置随机运算符?，默认情况下，该运算符是Mersenne扭曲器，它返回64位值，这应该足够了。

说明：

• ⎕RL←⍺：将随机种子设置为⍺。
• ?⍵2⍴0：生成⍵0到1之间的随机数对。
• {... }/：对每对应用以下功能：
  • (.5*⍨¯2×⍟⍺)×1○⍵×○2：计算Z0值（sqrt(-2 ln ⍺)×cos(2π⍵)）。

Perl，67岁

sub f{srand$_[0];map{cos(atan2(1,1)*rand 8)*sqrt-2*log rand}1..pop}

Box-Muller与其他条目一样。f按顺序获取参数S, N。

用：

$ perl -le 'sub f{srand$_[0];map{cos(atan2(1,1)*rand 8)*sqrt-2*log rand}1..pop}print for f(5,3)'
-1.59212831801942
0.432167710756345
-0.533673305924252

Java，164161字节

class B extends java.util.Random{B(int s,int n){super(s);for(;n-->0;System.out.println(Math.sqrt(-2*Math.log(nextDouble()))*Math.cos(2*Math.PI*nextDouble())));}}

这通过函数接收输入，并通过stdout输出。它使用Box-Muller方法。

Commodore 64 Basic，76 70 63字节

1INPUTS,N:S=R/(-S):F┌I=1TON:?S●(-2*LOG(R/(1)))*S╮(2*π*R/(1)):N─

由于PETSCII字符集包含一些Unicode中不存在的符号，因此我进行了替换：/= SHIFT+N，┌= SHIFT+O，●= SHIFT+Q，╮= SHIFT+I，─=SHIFT+E

这实现了标准的Box-Muller变换来生成数字。我选择了转换的sin（x）一半，因为Commodore 64 Basic对而言有两个字符的快捷方式sin()，但对于没有cos()。

尽管手册另有规定，但to参数的值RND 确实很重要：如果传递了负数，则随机数生成器不仅会重新播种，还会使用该数字播种。这使播种变得更加简单：POKE不需要只需要五个存储位置，我只需要对do做什么都不做RND，这会将代码从2行/ 121字节减少到1行/ 76字节。

编辑：通过意识到我可以结合这两个INPUT语句，节省了六个字节，而且后面的空格TO是可选的。

编辑：击败了另外七个：Commodore Basic确实将Pi作为内置常数，并且甚至可以在现代键盘上键入（SHIFT+PgDn如果您想知道的话）。

80386机器代码，72字节

代码的十六进制转储：

60 8b 7c 24 24 33 ed 8d 75 fb 8d 46 79 f7 e2 f7
f6 8b da b3 7f 0f cb d1 eb 89 1f d9 07 d9 e8 de
e9 33 ee 75 e5 d9 ed d9 c9 d9 f1 dc c0 d9 e0 d9
fa d9 c9 d9 eb de c9 dc c0 d9 ff de c9 d9 1f 83
c7 04 e2 c6 61 c2 04 00

这是源代码（可以由Visual Studio编译）：

__declspec(naked) void __fastcall doit(int count, unsigned seed, float* output)
{
    _asm {
                                // ecx = count
                                // edx = seed
        // save registers
        pushad;
        mov edi, [esp + 0x24];  // edi = pointer to output
        xor ebp, ebp;           // ebp = 0
        lea esi, [ebp - 5];     // esi = 4294967291 (a prime number)

    myloop:
        // Calculate the next random number
        lea eax, [esi + 121];   // eax = 116
        mul edx;
        div esi;
        mov ebx, edx;

        // Convert it to a float in the range 1...2
        mov bl, 0x7f;
        bswap ebx;
        shr ebx, 1;

        // Convert to range 0...1 and push onto the FPU stack
        mov [edi], ebx;
        fld dword ptr [edi];
        fld1;
        fsubp st(1), st;

        // Make 2 such random numbers
        xor ebp, esi;
        jnz myloop;

        // Calculate sqrt(-2*ln(x))
        fldln2;
        fxch;
        fyl2x;
        fadd st, st(0);
        fchs;
        fsqrt;

        // Calculate cos(2*pi*y)
        fxch st(1);
        fldpi;
        fmul;
        fadd st, st(0);
        fcos;

        // Calculate and write output
        fmulp st(1), st;
        fstp dword ptr [edi];
        add edi, 4;

        // Repeat
        loop myloop

        // Return
        popad;
        ret 4;
    }
}

在这里，我使用Lehmer随机数生成器。它使用以下算法：

x(k+1) = 116 * x(k) mod 4294967291

这里4294967291是一个大（2 ^ 32-5）质数，而116是一个小（小于128；请参见下文）数，它是其原始根。我选择了一个基本根，该根在二进制表示中具有或多或少的零和一的随机分布（01110100）。如果种子非零，则此RNG的最大可能周期为4294967290。

我在这里使用的相对较小的数字（116和4294967291，也可以表示为-5）使我可以利用lea指令编码：

8d 46 79     lea eax, [esi+121]

如果数字可以容纳1个字节，则将其组装为3个字节。

乘法和除法使用edx和eax作为它们的工作寄存器，这就是为什么我seed在函数中设置了第二个参数（fastcall调用约定edx用来传递第二个参数）的原因。此外，第一个参数传入ecx，这是保存计数器的好地方：可以在1条指令中组织循环！

e2 c6        loop myloop

要将整数转换为浮点数，我利用了单精度浮点数的表示形式：如果我将高9位（指数）设置为位模式001111111，并保留23个低位为随机数，得到一个在1 ... 2。范围内的随机数 我从这里接受了这个主意。要设置高9位，我在上使用了一些位摆弄ebx：

mov ebx, edx;    xxxxxxxx|yyyyyyyy|zzzzzzzz|aaaaaaaa
mov bl, 0x7f;    xxxxxxxx|yyyyyyyy|zzzzzzzz|01111111
bswap ebx;       01111111|zzzzzzzz|yyyyyyyy|xxxxxxxx
shr ebx, 1;      00111111|1zzzzzzz|zyyyyyyy|yxxxxxxx

为了生成两个随机数，我使用了2次迭代的嵌套循环。我组织了xor：

xor ebp, esi;    first time, the result is -5
jnz myloop;      second time, the result is 0 - exit loop

浮点代码实现Box-Muller变换。

哈斯克尔 118144 

import System.Random;h z=let(u,r)=random z in(cos$2*pi*fst(random r)::Float)*sqrt(-2*log u):h r;g=(.(h.mkStdGen)).take

用法示例：

*Main> g 3 0x6AE4A92CAFA8A742
[0.50378895,-0.20593005,-0.16684927]
*Main> g 6 0x6AE4A92CAFA8A742
[0.50378895,-0.20593005,-0.16684927,1.1229043,-0.10026576,0.4279402]
*Main> g 6 0xE09B1088DF461F7D
[2.5723906,-0.5177805,-1.3535261,0.7400385,3.5619608e-3,-8.246434e-2]

返回类型的random限制为Float，这使得random在[0，1）中生成均匀的浮点数。从那时起，这是一个Simlpe Box-Muller公式，其中包含一些毫无意义的魔术，可用于生成列表。

戈尔夫卢阿，63 70

Golflua信息和说明。

\g(n,s)`_ENV,b=M,{}rs(s)~@i=1,n b[i]=q(l(r()^-2))*c(r()*pi)$~b$

返回包含值的表。在示例中，我使用~T.u( )，与return table.unpack( )lua中的相同。

> ~T.u(g(3,1234567))
0.89302672974232 0.36330401643578 -0.64762161593981
> ~T.u(g(5,1234567))
0.89302672974232 0.36330401643578 -0.64762161593981 -0.70654636393063 -0.65662878785425
> ~T.u(g(5,7654321))
0.3867923683064 -0.31758512485963 -0.58059120409317 1.2079459300077 1.1500121921242

通过将函数的环境设置为M（aka math），可以节省很多字符。

SAS，108

我已经在R中发布了一个比这短的答案，但是PPCG上的SAS答案很少，那么为什么不添加另一个答案呢？

%macro f(s,n);data;do i=1 to &n;x=sqrt(-2*log(ranuni(&s)))*cos(8*atan2(1,1)*ranuni(&s));put x;end;run;%mend;

有一些空格：

%macro f(s, n);
    data;
        do i = 1 to &n;
            x = sqrt(-2 * log(ranuni(&s))) * cos(8 * atan2(1, 1) * ranuni(&s));
            put x;
        end;
    run;
%mend;

这定义了一个可以称为like的宏%f(5, 3)。宏执行一个数据步骤，循环遍历整数1到N，并在每次迭代时使用Box-Muller计算随机法线偏差，并使用该put语句将其打印到日志中。

SAS没有pi的内置函数，因此我们能做的最好是使用反正切值对其进行近似。

该ranuni()函数（不推荐使用，但比新函数需要更少的字符）从均匀分布中返回一个随机数。SAS文档的周期为2 ^ 31-2，但没有提供有关RNG实施的全部详细信息。

在SAS宏中，宏变量以前置引用，&并在运行时解析为其值。

正如您可能已经看到的那样，SAS很少是代码高尔夫竞赛中的真正竞争者。

Java，193个字节

尽管这不能胜过当前的Java领导者，但我还是决定发布以显示另一种计算方法。这是OpenJDK的高尔夫版本nextGaussian()。

class N extends java.util.Random{N(int s,int n){super(s);for(float a,v;n-->0;System.out.println(v*Math.sqrt(-2*Math.log(a)/a)))for(a=0;a>=1|a==0;a=v*v+(v=2*nextFloat()-1)*v)v=2*nextFloat()-1;}}

带换行符：

class N extends java.util.Random{
    N(int s,int n){
        super(s);
        for(float a,v;
            n-->0;
            System.out.println(v*Math.sqrt(-2*Math.log(a)/a)))
                for(a=0;
                    a>=1|a==0;
                    a=v*v+(v=2*nextFloat()-1)*v)v=2*nextFloat()-1;
    }
}

T-SQL，155个字节

CREATE PROC R(@S BIGINT,@N INT)AS
DECLARE @ INT=0,@K INT=8388607WHILE @<@N
BEGIN
SELECT SQRT(-2*LOG(RAND(@S*@%@K)))*COS(2*PI()*RAND(@S*9*@%@K))SET @+=1
END

与EXEC RS，N一起使用，因为T-SQL中没有STD_IN，其中S和N分别是种子和N。当S> 2 ^ 16（可能在此之前，但我不能保证）时，S会产生“随机”（RAND（种子）是一个非常糟糕的随机数实现）序列。到目前为止，与大多数解决方案一样使用Box-Muller。8388607是2 ^ 23-1，希望可以生成2 ^ 20个不同的值。

Powershell，164字节

Param($s,$n)$q=2147483647
$a=GET-RANDOM -SETSEED $s
FOR(;$n---gt0;){$a=GET-RANDOM
$b=GET-RANDOM
[math]::SQRT(-2*[math]::LOG($a/$q))*[math]::COS(2*[math]::PI*$b/$q)}

与Box-Muller的大多数答案相同。对Powershell不太有经验，因此对打高尔夫球的任何帮助将不胜感激。

Ruby，72个字节

->n,s{include Math;srand s;n.times{p sqrt(-2*log(rand))*sin(2*rand*PI)}}

输入（作为lambda函数）：

f.(6, 12353405)

输出：

-1.1565142460805273
0.9352802655317097
1.3566720571574993
-0.9683973210257978
0.9851210877202192
0.14709635752306677

PS：我想知道是否可以进一步打高尔夫球。我只是一个初学者。

Matlab，77岁

第一个输入应该是n，第二个输入s。

a=input('');
rand('seed',a(2));
for i=1:a;
    (-2*log(rand))^.5*cos(2*pi*rand)
end

八度，91 96 88字节

function r=n(s,n)rand("seed",s);x=rand(2,n);r=cos(2*pi*x(1,:)).*sqrt(-2*log(x(2,:)));end

或者，使用空格：

function r=n(s,n)
  rand("seed",s);
  x=rand(2,n);
  r=cos(2*pi*x(1,:)).*sqrt(-2*log(x(2,:)));
end

将种子放在最前面，然后使用Box-Mueller方法。

注意：八度允许生成随机数数组，并且可以在这些数组上使用标准运算，从而产生数组输出。所述.*操作者是元件逐元素乘法两个阵列以产生结果。

Pyth，32个字节

由于Pyth现在具有新功能，因此现在没有在超级引号中使用Python。另一个Box-Mueller。

 .xvzVQ*@_y.lOZ2.71 2.ty*3.14OZ1

一开始的空间很重要。

.xvz             Seed RNG with evaluated input
VQ               For N in second input
*                Multiplication
 @       2       Square root
   _y            Times negative 2
    .l )         Natural log
     OZ          Of random float (RNG with zero give [0, 1) float)
 .t       1      Cosine from list of trig functions
  y              Double
   *             Multiplication
    .nZ          Pi from constants list
    OZ           Random Float

播种似乎在在线解释器中不起作用，但在本地版本中效果很好。在线翻译似乎是固定的，所以这里的一个固定链接：固定链接

STATA，85字节

di _r(s)_r(n)
set se $s
set ob $n
g a=sqrt(-2*ln(runiform()))*cos(2*runiform()*_pi)
l

通过标准输入（第一个数字为S，然后为N）进行输入。将种子设置为S。将观察数设置为N。创建变量并将其值设置为Box Muller变换值（感谢@Alex展示）。然后在表中列出所有观测值，列标题为a，并在其旁边排列观测值编号。如果这些都不行，请告诉我，然后我可以删除标题和/或观察号。

R，89字节

我知道R之前已经做过，但是我想展示一种不同于其他所有人使用的Box-Muller的方法。我的解决方案使用中心极限定理。

f=function(S,N){set.seed(S);a=1000;for(i in(1:N)){print(sqrt(12/a)*(sum(runif(a))-a/2))}}

TI-Basic，74个字节

Prompt S,N:S→rand:For(X,1,N:0→A:0→V:0→W:While A≥1 or A=0:2rand-1→V:2rand-1→W:V²+W²→A:End:Disp VW√(Aֿ¹-2log(A:End

1      1111111   11   1111111111111111111     1111   111111   1111111   11111111111111  11    111111111   111

该¹实际上是逆算子。

Perl中，150个 108 107字节

这使用了Marsaglia Polar方法。用f（S，N）调用。

将的分配$a移到的计算中$c。

107：

sub f{srand$_[0];map{do{$c=($a=-1+2*rand)**2+(-1+2*rand)**2}until$c<1;print$a*sqrt(-2*log($c)/$c)}1..$_[1]}

删除了备用号码存储区和的定义$b。

108：

sub f{srand$_[0];map{do{$a=-1+2*rand,$c=$a**2+(-1+2*rand)**2}until$c<1;print$a*sqrt(-2*log($c)/$c)}1..$_[1]}

150：

sub f{srand$_[0];map{$h?$h=!print$s:do{do{$a=-1+2*rand,$b=-1+2*rand,$c=$a*$a+$b*$b}until$c<1;$d=sqrt(-2*log($c)/$c);$s=$b*$d;$h=print$a*$d;}}1..$_[1]}

迅速，144 142

没什么聪明的，只是看看Swift是如何工作的。

import Foundation;func r(s:UInt32,n:Int){srand(s);for i in 0..<n{println(sqrt(-2*log(Double(rand())/0xffffffff))*sin(2*Double(rand())*M_PI))}}

我希望可以使用（0 ... n）.map {}，但是除非您使用参数，否则编译器似乎无法识别map {}。

Haskell，97个字节

import System.Random
h(a:b:c)=sqrt(-2*log a::Float)*cos(2*pi*b):h c
f a=take a.h.randoms.mkStdGen

在线尝试！

只是您的基本Box-Muller变换，在无限数量的随机数上。

Python 3，118字节

from random import*
from math import*
def f(s,n):seed(s);return[sqrt(-2*log(random()))*cos(tau*random())for _ in[0]*n]

在线尝试！

SmileBASIC，81个字节

好吧，既然我已经回答了第一个问题，剩下的我就要做...

生成随机数很便宜，但是播种RNG使用该语言中最长的内置函数RANDOMIZE。

DEF N S,N
RANDOMIZE.,S
FOR I=1TO N?SQR(-2*LOG(RNDF()))*COS(PI()*2*RNDF())NEXT
END

也许有某种方法可以优化公式。我看不到使用两个RNG调用的要求。