Meydan okuma

Girişsiz olan ve uzunluğu $1$ olan bir vektörü teorik olarak düzgün bir rastgele yönde çıkaran bir program veya işlev yazın .

Bu, açıklanan küre üzerindeki rastgele bir noktaya eşdeğerdir.

böyle bir dağıtım sonuçlandı

Çıktı

denkleminin hassasiyet limitlerine sadık kaldığı teorik olarak düzgün rastgele dağılımdan üç değişken .$x^2+y^2+z^2=1$

Meydan açıklamalar

• Rastgele dağılımın teorik olarak tek tip olması gerekir . Yani, eğer sözde rasgele sayı üreteci, gerçek sayılardan gerçek bir RNG ile değiştirilecekse , küre üzerinde noktaların düzgün rastgele dağılmasıyla sonuçlanacaktır.
• Düzgün bir dağılımdan üç rasgele sayı üretmek ve bunları normalleştirmek geçersizdir: üç boyutlu boşluğun köşelerine doğru bir önyargı olacaktır.
• Benzer şekilde, düzgün bir dağılımdan iki rasgele sayı üretmek ve bunları küresel koordinatlar olarak kullanmak geçersizdir: kürenin kutuplarına doğru bir önyargı olacaktır.
• Aşağıdakileri içeren ancak bunlarla sınırlı olmayan algoritmalar ile uygun tek biçimlilik elde edilebilir:
  • A'dan üç rasgele sayı , ve oluşturun$x$$y$$z$0 , normal çevresinde (Gauss) dağıtım ve normalize. $0$
    • Uygulama örneği
  • Oluşturmak üç rasgele sayılar , ve , bir gelen muntazam aralığında dağılımı . Vektörün uzunluğunu hesaplayın . O zaman, eğer$x$$y$$z$( - 1 , 1 ) l = √$(-1,1)$$l=\sqrt{x^2+y^2+z^2}$$l>1$ ise vektörü reddedin ve yeni bir sayı kümesi oluşturun. Aksi takdirde, ise vektörü normalleştirir ve sonucu döndürür. $l \leq 1$
    • Uygulama örneği
  • İki rasgele sayı oluşturmak ve bir gelen muntazam aralığında dağılımı ve bunu gibi küresel koordinatlar dönüştürmek: böylece , ve$i$$j$( 0 , 1 ) θ$(0,1)$ $$\begin{align}\theta &= 2 \times \pi \times i\\\\\phi &= \cos^{-1}(2\times j -1)\end{align}$$ $x$$y$$z$ ile hesaplanabilir $$\begin{align}x &= \cos(\theta) \times \sin(\phi)\\\\y &= \sin(\theta) \times \sin(\phi)\\\\z &= \cos(\phi)\end{align}$$
    • Uygulama örneği
• Cevabınıza, kullandığınız algoritmanın kısa bir açıklamasını sağlayın.
• Küre noktası toplama hakkında daha fazla bilgi edinin MathWorld'de seçimi hakkında .

Çıktı örnekleri

[ 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]

Genel açıklamalar

• Bu kod golf , yani her dilde en az bayt kullanan cevap kazanıyor.
• Standart kurallar , G / Ç kuralları ve boşluk deliği kuralları uygulanır.
• Lütfen bir Çevrimiçi Deneyin kodunuzun çalıştığını göstermek için bir Deneyin bağlantısını kullanın.
• Lütfen cevabınızı kodunuzun açıklamasıyla motive edin.

Wolfram Dili (Mathematica) , 20 bayt

RandomPoint@Sphere[]

Çevrimiçi deneyin!

Teneke söylediklerini aynen yapar.

R , 23 bayt

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

Çevrimiçi deneyin!

$\mathcal N(0,1)$ dağılımının 3 gerçekleşmesini oluşturur ve elde edilen vektörü normalleştirir.

1000 gerçekleştirmenin arsa:

x86-64 Makine Kodu - 63 62 55 49 bayt

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  

Değiştirilen ikinci algoritmayı kullanır. [x, y, z, 0]Xmm0 içindeki vektörü döndürür .

Açıklama:

push 4Fh
push 3f800000h

1 ve 2 ^ 31 değerini yığına kayan nokta olarak iter. Veri işareti uzantısı nedeniyle çakışıyor ve birkaç bayt kaydediliyor.

vbroadcastss xmm1,dword ptr [rsp+5] 2 ^ 31 için değeri xmm1'in 4 konumuna yükler.

rdrand      eax  
jnc         rand  
movd        xmm0,eax

Rasgele 32 bit tam sayı oluşturur ve xmm0'ın altına yükler.

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

Rasgele bir 32 bit tam sayı üretir, onu yüzdürmeye (işaretli) dönüştür ve -1 ile 1 arasında sayı elde etmek için 2 ^ 31 ile böl.

vdpps xmm2,xmm0,xmm0,7Fhüst yüzgecin maskelenerek kendi başına bir nokta ürünü kullanarak alt 3 yüzgecinin karelerini ekler. Bu uzunluğu verir

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

Kare uzunluğu 1 ile karşılaştırır ve 1'e eşit değilse değerleri reddeder. Kare uzunluğu bir ise, uzunluk da birdir. Bu, vektörün normalize olduğu ve karekök kaydettiği ve böldüğü anlamına gelir.

pop         rax  
pop         rax 

Yığını geri yükle.

ret xmm0 içindeki değeri döndürür

Çevrimiçi deneyin .

Python 2,86 bayt

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

Çevrimiçi deneyin!

Z koordinatını 1 ile 1 arasında eşit olarak oluşturur. Sonra x ve y koordinatları yarıçap dairesinde eşit olarak örneklenir (1-z*z)**.5.

Küresel dağılımın z koordinatı üzerinde tekdüze bir faktörde olduğu açık olmayabilir (ve böylece her koordinat üzerinde). Bu, boyut 3 için özel bir şeydir. Bu kanıtı , bir kürenin yatay bir diliminin yüzey alanının yüksekliğiyle orantılı olduğunu görün. Ekvatorun yanındaki dilimler daha büyük bir yarıçapa sahip olsalar da, direğe yakın dilimler daha fazla içe doğru başlıklandırılır ve bu iki efekt tam olarak iptal edilir.

Bu dairede rastgele bir açı oluşturmak için, hayali birimi 1j0 ile 4 arasında düzgün rastgele bir güce yükseltiriz; bu da bizi herhangi bir içe aktarmaya ihtiyaç duyan trig işlevlerine, pi veya e'ye ihtiyaç duymadan kurtarır. Ardından asıl hayali kısmı çıkarıyoruz. İki koordinat için karmaşık bir sayı çıkarabilirsek, son satır tam olabilir print a,z.

86 bayt

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

Çevrimiçi deneyin!

Üç normal üretir ve sonucu ölçeklendirir.

Numune ile Python 2 , 57 bayt

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

Çevrimiçi deneyin!

sum(a*a)**.5daha kısa linalg.norm(a). dot(a,a)Aynı uzunluk için de yapabiliriz sum(a*a). Python 3'te bu a@a, yeni operatörün kullanılmasıyla kısaltılabilir @.

Octave , 40 33 22 bayt

3d standart bir normal dağılım oluşturur ve vektörü normalleştiririz:

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

Çevrimiçi deneyin!

Birlik C # , 34 bayt

f=>UnityEngine.Random.onUnitSphere

Birliğin birim küre rasgele değerleri için bir yerleşimi vardır, bu yüzden göndermeyi düşündüm.

MATL , 10 bayt

1&3Xrt2&|/

Çevrimiçi deneyin!

açıklama

Bu, mücadelede açıklanan ilk yaklaşımı kullanır.

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

Ruby , 34 50 49 bayt

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

Çevrimiçi deneyin!

3 sayı dizisini döndürür [z,y,x].

xve 0 ile 4 arasında rastgele bir güce (-1 karekökü) yyükseltilerek üretilir i. Bu karmaşık sayının zPisagor teoremine uygun değere göre uygun şekilde ölçeklendirilmesi gerekir :(x**2 + y**2) + z**2 = 1.

zArasında 1 ve 1 olmasa da hemen dA / küre aracılığıyla bir dilim için dz sürekli açıktır, homojen olarak dağıtılmış bir sayı yeterli olan (ilk elde edildiği) koordinat (ve aynı yarıçaplı bir daire olarak çevresine eşit bütün küre.

Bu, görünüşe göre, hesabı olmayan bir şekilde tanımlayan Arşimed tarafından keşfedildi ve Arşimet Şapkası Teoremi olarak bilinir. Bkz. Https://brilliant.org/wiki/surface-area-sphere/

Xnor'ın cevabı hakkındaki yorumlardan başka bir referans. Şaşırtıcı derecede basit bir formülü açıklayan şaşırtıcı derecede kısa bir URL: http://mathworld.wolfram.com/Zone.html

05AB1E , 23 22 bayt

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

2. algoritmayı uygular.

Çevrimiçi deneyin veya birkaç rasgele çıktı alın .

Açıklama:

$[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 bayt ^*

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

Algoritmayı kullanarak "normalde 3 dağıtılmış değer üret ve bu vektörü normalleştir".

İfadeli bir programın sonlandırılması, program sona erdikten sonra Ana Ekranda sonucu otomatik olarak yazdırır, bu nedenle sonuç yalnızca oluşturulan ve kara delikli değil aslında gösterilir.

*: randNorm(A, iki baytlık bir belirteç , geri kalan tek baytlı simgeler . İlkini saydım (kaçınılmaz) :, onsuz 14 byte olur. Tek harfli bir adla program olarak kaydedilen, 9 byte dosya sistemi yükünü içeren 24 byte belleği alır.

JavaScript (ES7),  77 76  75 bayt

kullanarak ^3. algoritmayı uygular.$\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]

Çevrimiçi deneyin!

Yorumlananlar

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 bayt

Uygular 2 ^nd algoritması.

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

Çevrimiçi deneyin!

Yorumlananlar

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

İşleme 26 bayt

Tam program

print(PVector.random3D());

Bu uygulama 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 bayt

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

Çevrimiçi deneyin!

İlk algoritmayı uygular.

Python 2 , 107 103 bayt

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

Çevrimiçi deneyin!

İkinci algoritmayı uygular.

Haskell , 125 123 119 118 bayt

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

Çevrimiçi deneyin!

Üç üniforma rastgele ve ret örnekleme yapar.

JavaScript, 95 bayt

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)

Sen yok gerek yok girişine a.

Julia 1.0 , 24 bayt

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

Çevrimiçi deneyin!

Standart sapma 1 ile 0 civarında normal bir dağılımdan çizilmiş 3 değerlik bir vektör çizer. Sonra onları normalleştirir.

MathGolf , 21 19 18 bayt

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

2. algoritmanın uygulanması.

Çevrimiçi deneyin veya aynı anda birkaç çıktı daha görün .

Açıklama:

{              }▲   # 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)

Java 8 ( @Arnauld değiştirilmiş 3. algoritma), 131 126 119 111 109 bayt

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

Liman içinde @Arnauld 'ın JavaScript cevap , çok emin onu upvote olun! @ OlivierGrégoire
sayesinde -2 bayt .

Bu şöyle uygulanır:

$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\}$

Çevrimiçi deneyin.

Önceki 3. algoritma uygulaması ( 131 126 119 bayt):

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

Olarak uygulandı:

$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))\}$

Çevrimiçi deneyin.

Açıklama:

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

Java 8 (2. algoritma), 153 143 bayt

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

Çevrimiçi deneyin.

2. algoritma:

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 bayt

Arnauld Limanı'nın 2. algoritmayı uygulaması .

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

Dene

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 bayt

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

Çevrimiçi deneyin!

Algoritma kullanır # 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 bayt

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

Çevrimiçi deneyin

Orijinal çözüm:

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

İlk önce tanımladım:

OCaml'in Random.floatişlevi sınırları içerir. Sonra,

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