挑战

编写一个程序或函数，该程序或函数不输入任何内容，并在理论上均匀的随机方向上输出长度为的向量。$1$

这等效于所描述的球面上的随机点

导致这样的分布

输出量

从理论上均匀的随机分布中得出三个浮点数，方程满足精度极限。$x^2+y^2+z^2=1$

挑战备注

• 理论上，随机分布必须是均匀的。也就是说，如果将伪随机数生成器替换为实数中的真实RNG ，则会导致球体上点的均匀随机分布。
• 从均匀分布中生成三个随机数并将它们归一化是无效的：将会对三维空间的各个角产生偏差。
• 同样，从均匀分布中生成两个随机数并将其用作球面坐标也是无效的：向球体的极点会产生偏差。
• 适当的均匀性可以通过算法实现，这些算法包括但不限于：
  • 根据附近的正态（高斯）分布生成三个随机数，和并将其标准化。 $x$$y$$z$$0$
    • 实施实例
  • 根据范围内的均匀分布生成三个随机数，和$x$$y$$z$$(-1,1)$。通过l = √计算向量的长度$l=\sqrt{x^2+y^2+z^2}$。然后，如果$l>1$，则拒绝该向量并生成一组新的数字。否则，如果$l \leq 1$，标准化载体并返回结果。
    • 实施实例
  • 生成两个随机数$i$和$j$从均匀的范围内分布$(0,1)$并将其转换为球面坐标，像这样： $$\begin{align}\theta &= 2 \times \pi \times i\\\\\phi &= \cos^{-1}(2\times j -1)\end{align}$$ 因此可以通过 x计算$x$，$y$和$z$ $$\begin{align}x &= \cos(\theta) \times \sin(\phi)\\\\y &= \sin(\theta) \times \sin(\phi)\\\\z &= \cos(\phi)\end{align}$$
    • 实施实例
• 在您的答案中提供您正在使用的算法的简短描述。
• 在MathWorld上阅读有关球体点拾取的更多信息。

输出示例

[ 0.72422852 -0.58643067  0.36275628]
[-0.79158628 -0.17595886  0.58517488]
[-0.16428481 -0.90804027  0.38532243]
[ 0.61238768  0.75123833 -0.24621596]
[-0.81111161 -0.46269121  0.35779156]

一般说明

• 这是代码高尔夫球，因此使用每种语言中最少字节的答案将获胜。
• 适用标准规则，I / O规则和漏洞规则。
• 请提供一个在线试用链接-或等效链接，以演示您的代码是否有效。
• 请通过解释代码来激发您的答案。

Wolfram语言（Mathematica），20个字节

RandomPoint@Sphere[]

在线尝试！

完全按照锡罐上的说明去做。

R，23个字节

x=rnorm(3)
x/(x%*%x)^.5

在线尝试！

生成的3层的实现$\mathcal N(0,1)$分布和归一化所得的矢量。

1000个实现的图解：

x86-64机器代码-63 62 55 49字节

6A 4F                push        4Fh  
68 00 00 80 3F       push        3F800000h  
C4 E2 79 18 4C 24 05 vbroadcastss xmm1,dword ptr [rsp+5]  
rand:
0F C7 F0             rdrand      eax  
73 FB                jnc         rand  
66 0F 6E C0          movd        xmm0,eax  
greaterThanOne:
66 0F 38 DC C0       aesenc      xmm0,xmm0  
0F 5B C0             cvtdq2ps    xmm0,xmm0  
0F 5E C1             divps       xmm0,xmm1  
C4 E3 79 40 D0 7F    vdpps       xmm2,xmm0,xmm0,7Fh  
0F 2F 14 24          comiss      xmm2,dword ptr [rsp]  
75 E9                jne         greaterThanOne
58                   pop         rax  
58                   pop         rax  
C3                   ret  

使用第二种算法，经过修改。返回[x, y, z, 0]xmm0 中的向量。

说明：

push 4Fh
push 3f800000h

将1和2 ^ 31的值作为浮点值压入堆栈。由于符号扩展，数据重叠，节省了几个字节。

vbroadcastss xmm1,dword ptr [rsp+5] 将2 ^ 31的值加载到xmm1的4个位置。

rdrand      eax  
jnc         rand  
movd        xmm0,eax

生成随机的32位整数并将其加载到xmm0的底部。

aesenc      xmm0,xmm0  
cvtdq2ps    xmm0,xmm0  
divps       xmm0,xmm1 

生成一个随机的32位整数，将其转换为浮点数（有符号），然后除以2 ^ 31以得到-1和1之间的数字。

vdpps xmm2,xmm0,xmm0,7Fh单独使用点乘积来添加下方3个浮点的平方，从而遮盖顶部浮点。这给出了长度

comiss      xmm2,dword ptr [rsp]  
jne          rand+9h (07FF7A1DE1C9Eh)

将长度的平方与1比较，如果不等于1，则拒绝该值。如果长度的平方为1，则长度也为1。这意味着向量已经被规范化并保存平方根和除法。

pop         rax  
pop         rax 

恢复堆栈。

ret 返回值xmm0

在线试用。

Python 2，86个字节

from random import*;R=random
z=R()*2-1
a=(1-z*z)**.5*1j**(4*R())
print a.real,a.imag,z

在线尝试！

从-1到1均匀地生成z坐标。然后在radius的圆上均匀地采样x和y坐标(1-z*z)**.5。

球面分布在z坐标上（因此在每个坐标上）均是因子均匀的，这可能并不明显。这是尺寸3的特殊之处。请参见证明球体水平切片的表面积与其高度成正比的证明。尽管赤道附近的切片具有较大的半径，但极点附近的切片的标题更多地向内，并且事实证明这两个效果完全抵消。

为了在该圆上生成一个随机角度，我们将虚数单位提高1j到0到4之间的均匀随机幂，这使我们免于需要三角函数pi或e，而其中的任何一个都需要输入。然后，我们提取真实的虚部。如果我们可以为两个坐标输出复数，则最后一行可能只是print a,z。

86字节

from random import*
a,b,c=map(gauss,[0]*3,[1]*3)
R=(a*a+b*b+c*c)**.5
print a/R,b/R,c/R

在线尝试！

生成三个法线并缩放结果。

带有numpy的Python 2，57个字节

from numpy import*
a=random.randn(3)
print a/sum(a*a)**.5

在线尝试！

sum(a*a)**.5比短linalg.norm(a)。我们也可以做dot(a,a)与相同的长度sum(a*a)。在Python 3中，可以简化为a@a使用new运算符@。

八度，40 33 22字节

我们采样形成3d标准正态分布，并对向量进行归一化：

(x=randn(1,3))/norm(x)

在线尝试！

Unity C＃，34个字节

f=>UnityEngine.Random.onUnitSphere

Unity具有单位球面随机值的内置函数，因此我认为应该发布它。

MATL，10字节

1&3Xrt2&|/

在线尝试！

说明

这使用了挑战中描述的第一种方法。

1&3Xr  % Generate a 1×3 vector of i.i.d standard Gaussian variables
t      % Duplicate
2&|    % Compute the 2-norm
/      % Divide, element-wise. Implicitly display

红宝石，34 50 49字节

->{[z=rand*2-1]+((1-z*z)**0.5*1i**(rand*4)).rect}

在线尝试！

返回3个数字组成的数组[z,y,x]。

x和y是通过将i（-1的平方根）提高到0到4之间的随机乘方来生成的。此复数需要z根据毕达哥拉斯定理根据值适当缩放：(x**2 + y**2) + z**2 = 1.

的z坐标（其首先产生）只是之间-1和1虽然没有立即明显，DA / DZ用于通过球体的切片是恒定的均匀分布的数目（并且等于同一半径的圆作为周边整个领域。）。

这显然是由阿基米德发现的，他用一种非微积分的方式对其进行了描述，并且被称为阿基米德Hat-B​​ox定理。参见https://brilliant.org/wiki/surface-area-sphere/

有关xnor答案的评论的另一参考。一个简短的URL，描述了一个简单的公式：http： //mathworld.wolfram.com/Zone.html

05AB1E，23 22 字节

[тε5°x<Ýs/<Ω}DnOtDî#}/

实现第二种算法。

在线尝试或获得更多随机输出。

说明：

$[0,1)$$0.00001$$0.000000001$59

[            # Start an infinite loop:
 тε          #  Push 100, and map (basically, create a list with 3 values):
   5°        #   Push 100,000 (10**5)
     x       #   Double it to 200,000 (without popping)
      <      #   Decrease it by 1 to 199,999
       Ý     #   Create a list in the range [0, 199,999]
        s/   #   Swap to get 100,000 again, and divide each value in the list by this
          <  #   And then decrease by 1 to change the range [0,2) to [-1,1)
           Ω #   And pop and push a random value from this list
  }          #  After the map, we have our three random values
   D         #   Duplicate this list
    n        #   Square each inner value
     O       #   Take the sum of these squares
      t      #   Take the square-root of that
       D     #   Duplicate that as well
        î    #   Ceil it, and if it's now exactly 1:
         #   #    Stop the infinite loop
}/           # After the infinite loop: normalize by dividing
             # (after which the result is output implicitly)

TI-BASIC，15字节^*

:randNorm(0,1,3
:Ans/√(sum(Ans²

使用算法“生成3个正态分布的值并将该向量归一化”。

以表达式结尾的程序会在程序终止后自动在主屏幕上显示结果，因此结果会真正显示出来，而不仅仅是生成和填充。

*：randNorm(是两个字节的令牌，其余的是一个字节的令牌。我已经计算了初始的（不可避免的）:，如果没有的话，它将是14个字节。另存为一个带有一个字母的名称的程序，它将占用24个字节的内存，其中包括9个字节的文件系统开销。

JavaScript（ES7）， 77 76  75字节

使用实现^第三种算法$\sin(\phi)=\sin(\cos^{-1}(z))=\sqrt{1-z^2}$

with(Math)f=_=>[z=2*(r=random)()-1,cos(t=2*PI*r(q=(1-z*z)**.5))*q,sin(t)*q]

在线尝试！

已评论

with(Math)                       // use Math
f = _ =>                         //
  [ z = 2 * (r = random)() - 1,  // z = 2 * j - 1
    cos(                         //
      t =                        // θ =
        2 * PI *                 //   2 * π * i
        r(q = (1 - z * z) ** .5) // q = sin(ɸ) = sin(arccos(z)) = √(1 - z²)
                                 // NB: it is safe to compute q here because
                                 //     Math.random ignores its parameter(s)
    ) * q,                       // x = cos(θ) * sin(ɸ)
    sin(t) * q                   // y = sin(θ) * sin(ɸ)
  ]                              //

JavaScript（ES6），79个字节

实现^第二算法。

f=_=>(n=Math.hypot(...v=[0,0,0].map(_=>Math.random()*2-1)))>1?f():v.map(x=>x/n)

在线尝试！

已评论

f = _ =>                         // f is a recursive function taking no parameter
  ( n = Math.hypot(...           // n is the Euclidean norm of
      v =                        // the vector v consisting of:
        [0, 0, 0].map(_ =>       //
          Math.random() * 2 - 1  //   3 uniform random values in [-1, 1]
        )                        //
  )) > 1 ?                       // if n is greater than 1:
    f()                          //   try again until it's not
  :                              // else:
    v.map(x => x / n)            //   return the normalized vector

处理 26个字节

完整程序

print(PVector.random3D());

这是实现https://github.com/processing/processing/blob/master/core/src/processing/core/PVector.java

  static public PVector random3D(PVector target, PApplet parent) {
    float angle;
    float vz;
    if (parent == null) {
      angle = (float) (Math.random()*Math.PI*2);
      vz    = (float) (Math.random()*2-1);
    } else {
      angle = parent.random(PConstants.TWO_PI);
      vz    = parent.random(-1,1);
    }
    float vx = (float) (Math.sqrt(1-vz*vz)*Math.cos(angle));
    float vy = (float) (Math.sqrt(1-vz*vz)*Math.sin(angle));
    if (target == null) {
      target = new PVector(vx, vy, vz);
      //target.normalize(); // Should be unnecessary
    } else {
      target.set(vx,vy,vz);
    }
    return target;
  }

Python 2，86个字节

from random import*
x,y,z=map(gauss,[0]*3,[1]*3);l=(x*x+y*y+z*z)**.5
print x/l,y/l,z/l

在线尝试！

实现第一个算法。

Python 2中，107个 103字节

from random import*
l=2
while l>1:x,y,z=map(uniform,[-1]*3,[1]*3);l=(x*x+y*y+z*z)**.5
print x/l,y/l,z/l

在线尝试！

实现第二种算法。

Haskell中，125个 123 119 118字节

import System.Random
f=mapM(\_->randomRIO(-1,1))"lol">>= \a->last$f:[pure$(/n)<$>a|n<-[sqrt.sum$map(^2)a::Double],n<1]

在线尝试！

进行三个制服随机抽样和拒绝抽样。

JavaScript，95个字节

f=(a=[x,y,z]=[0,0,0].map(e=>Math.random()*2-1))=>(s=Math.sqrt(x*x+y*y+z*z))>1?f():a.map(e=>e/s)

你并不需要不输入a。

朱莉娅1.0，24字节

x=randn(3)
x/hypot(x...)

在线尝试！

绘制一个3个值的向量，该向量是从0周围的正态分布中提取的，标准差为1。然后将其标准化。

MathGolf，21 19 18 字节

{╘3Ƀ∞(ß_²Σ√_1>}▲/

第二算法的实现。

在线尝试或同时查看更多输出。

说明：

{              }▲   # Do-while true by popping the value:
 ╘                  #  Discard everything on the stack to clean up previous iterations
  3É                #  Loop 3 times, executing the following three operations:
    ƒ               #   Push a random value in the range [0,1]
     ∞              #   Double it to make the range [0,2]
      (             #   Decrease it by 1 to make the range [-1,1]
       ß            #  Wrap these three values into a list
        _           #  Duplicate the list of random values
         ²          #  Square each value in the list
          Σ         #  Sum them
           √        #  And take the square-root of that
            _       #  Duplicate it as well
             1>     #  And check if it's larger than 1
                 /  # After the do-while, divide to normalize
                    # (after which the entire stack joined together is output implicitly,
                    #  which is why we need the `╘` to cleanup after every iteration)

爪哇8（@Arnauld的改性第三算法），131个 126 119 111 109字节

v->{double k=2*M.random()-1,t=M.sqrt(1-k*k),r[]={k,M.cos(k=2*M.PI*M.random())*t,M.sin(k)*t};return r;}

@Arnauld的JavaScript答案端口，请确保对其进行投票！
-2个字节，感谢@OlivierGrégoire。

这实现为：

$k = N\cap[-1,1)$
$t=\sqrt{1-k^2}$
$u=2\pi×(N\cap[0,1))$
$x,y,z = \{k, \cos(u)×t, \sin(u)×t\}$

在线尝试。

先前的第3种算法实现（131 126 119字节）：

Math M;v->{double k=2*M.random()-1,t=2*M.PI*M.random();return k+","+M.cos(t)*M.sin(k=M.acos(k))+","+M.sin(t)*M.sin(k);}

实施为：

$k = N\cap[-1,1)$
$t=2\pi×(N\cap[0,1))$
$x,y,z = \{k, \cos(t)×\sin(\arccos(k)), \sin(t)×\sin(\arccos(k))\}$

在线尝试。

说明：

Math M;                         // Math on class-level to use for static calls to save bytes
v->{                            // Method with empty unused parameter & double-array return
  double k=2*M.random()-1,      //  Get a random value in the range [-1,1)
         t=M.sqrt(1-k*k),       //  Calculate the square-root of 1-k^2
    r[]={                       //  Create the result-array, containing:
         k,                     //   X: the random value `k`
         M.cos(k=2*M.PI         //   Y: first change `k` to TAU (2*PI)
                     *M.random()//       multiplied by a random [0,1) value
                )               //      Take the cosine of that
                 *t,            //      and multiply it by `t`
         M.sin(k)               //   Z: Also take the sine of the new `k` (TAU * random)
                  *t};          //      And multiply it by `t` as well
  return r;}                    //  Return this array as result

爪哇8（第二算法），153个 143字节

v->{double x=2,y=2,z=2,l;for(;(l=Math.sqrt(x*x+y*y+z*z))>1;y=m(),z=m())x=m();return x/l+","+y/l+","+z/l;};double m(){return Math.random()*2-1;}

在线尝试。

第二种算法：

v->{                              // Method with empty unused parameter & String return-type
  double x=2,y=2,z=2,l;           //  Start results a,b,c all at 2
  for(;(l=Math.sqrt(x*x+y*y+z*z)) //  Loop as long as the hypotenuse of x,y,z
       >1;                        //  is larger than 1
    y=m(),z=m())x=m();            //   Calculate a new x, y, and z
  return x/l+","+y/l+","+z/l;}    //  And return the normalized x,y,z as result
double m(){                       // Separated method to reduce bytes, which will:
  return Math.random()*2-1;}      //  Return a random value in the range [-1,1)

Japt，20 字节

Arnauld实施第二种算法的端口。

MhV=3ÆMrJ1
>1?ß:V®/U

测试一下

MhV=3ÆMrJ1
Mh             :Get the hypotenuse of
  V=           :  Assign to V
    3Æ         :  Map the range [0,3)
      Mr       :    Random float
        J1     :    In range [-1,1)
>1?ß:V®/U      :Assign result to U
>1?            :If U is greater than 1
   ß           :  Run the programme again
    :V®/U      :Else map V, dividing all elements by U

Pyth，24个字节

W<1Ks^R2JmtO2.0 3;cR@K2J

在线尝试！

使用算法2

W                         # while 
 <1                       #   1 < 
   Ks                     #       K := sum(
     ^R2                  #               map(lambda x:x**2,
        Jm      3         #                    J := map(                            , range(3))
          tO2.0           #                             lambda x: random(0, 2.0) - 1           )):
                 ;        #   pass
                   R   J  # [return] map(lambda x:            , J)
                  c @K2   #                        x / sqrt(K)

OCaml，110 99 95字节

(fun f a c s->let t,p=f 4.*.a 0.,a(f 2.-.1.)in[c t*.s p;s t*.s p;c p])Random.float acos cos sin

$i$$j$let ... infun()

在线尝试

原始解决方案：

Random.(let a,c,s,i,j=acos,cos,sin,float 4.,float 2. in let t,p=i*.(a 0.),a (j-.1.) in[c t*.s p;s t*.s p;c p])

首先我定义：

OCaml的Random.float功能包括边界。然后，

$\phi = p$$\theta = t$$-$$i$$j$