Ihre Aufgabe ist es, ein Programm oder eine Funktion zu schreiben , die Zufallszahlen aus Intervall [0,1] mit fester Summe ausgibt .ns

Eingang

n, n≥1, Anzahl der zu generierenden Zufallszahlen

s, s>=0, s<=n, Summe der zu generierenden Zahlen

Ausgabe

Ein zufälliges nTupel von Gleitkommazahlen mit allen Elementen aus dem Intervall [0,1] und der Summe aller Elemente, die gleich sind s, wird auf eine bequeme, eindeutige Weise ausgegeben. Alle gültigen nTupel müssen innerhalb der Grenzen von Gleitkommazahlen gleich wahrscheinlich sein.

Dies ist gleichbedeutend mit einer gleichmäßigen Abtastung vom Schnittpunkt der Punkte innerhalb des nWürfels mit den Maßeinheiten und der n-1eindimensionalen Hyperebene, die durch (s/n, s/n, …, s/n)den Vektor verläuft und senkrecht zum Vektor verläuft (1, 1, …, 1)(siehe roter Bereich in Abbildung 1 für drei Beispiele).

Abbildung 1: Die Ebene der gültigen Ausgaben mit n = 3 und den Summen 0,75, 1,75 und 2,75

Beispiele

n=1, s=0.8 → [0.8]
n=3, s=3.0 → [1.0, 1.0, 1.0]
n=2, s=0.0 → [0.0, 0.0]
n=4, s=2.0 → [0.2509075946818119, 0.14887693388076845, 0.9449661625992032, 0.6552493088382167]
n=10, s=9.999999999999 → [0.9999999999999,0.9999999999999,0.9999999999999,0.9999999999999,0.9999999999999,0.9999999999999,0.9999999999999,0.9999999999999,0.9999999999999,0.9999999999999]

Regeln

• Ihr Programm sollte auf Ihrem Computer in weniger als einer Sekunde beendet sein, zumindest mit n≤10und allen gültigen s.
• Wenn Sie möchten, kann Ihr Programm am oberen Ende exklusiv sein, dh s<nund die Ausgabenummern aus dem halboffenen Intervall [0,1) (unterbrechen des zweiten Beispiels)
• Wenn Ihre Sprache keine Gleitkommazahlen unterstützt, können Sie die Ausgabe mit mindestens zehn Dezimalstellen nach dem Komma fälschen.
• Standard-Regelungslücken sind nicht zulässig, und Standard-Eingabe- / Ausgabemethoden sind zulässig.
• Das ist Code-Golf , also gewinnt der kürzeste Eintrag, gemessen in Bytes.

Wolfram Language (Mathematica) , 92-90 Bytes

If[2#2>#,1-#0[#,#-#2],While[Max[v=Differences@Sort@Join[{0,#2},RandomReal[#2,#-1]]]>1];v]&

Probieren Sie es online!

Code ohne Golf:

R[n_, s_] := Module[{v},
  If[s <= n/2,             (* rejection sampling for s <= n/2:                        *)
    While[
      v = Differences[Sort[
            Join[{0},RandomReal[s,n-1],{s}]]];         (* trial randoms that sum to s *)
      Max[v] > 1           (* loop until good solution found                          *)
    ];
    v,                     (* return the good solution                                *)
    1 - R[n, n - s]]]      (* for s > n/2, invert the cube and rejection-sample       *)

Hier ist eine Lösung, die in 55 Bytes funktioniert, aber im Moment (Mathematica Version 12) beschränkt ist auf, n=1,2,3weil es RandomPointabgelehnt wird, Punkte aus höherdimensionalen Hyperebenen zu zeichnen (in TIOs Version 11.3 schlägt dies ebenfalls fehl n=1). Es könnte jedoch nin Zukunft für höhere Versionen funktionieren :

RandomPoint[1&~Array~#~Hyperplane~#2,1,{0,1}&~Array~#]&

Probieren Sie es online!

Code ohne Golf:

R[n_, s_] :=
  RandomPoint[                           (* draw a random point from *)
    Hyperplane[ConstantArray[1, n], s],  (* the hyperplane where the sum of coordinates is s *)
    1,                                   (* draw only one point *)
    ConstantArray[{0, 1}, n]]            (* restrict each coordinate to [0,1] *)

JavaScript (Node.js) , 122 115 Byte

N=>W=S=>2*S>N?W(N-S).map(t=>1-t):(t=(Q=s=>n?[r=s-s*Math.random()**(1/--n),...r>1?[++Q]:Q(s-r)]:[])(S,n=N),Q?t:W(S))

Probieren Sie es online!

Python 2 , 144 128 119 Bytes

from random import*
def f(n,s):
 r=min(s,1);x=uniform(max(0,r-(r-s/n)*2),r);return n<2and[s]or sample([x]+f(n-1,s-x),n)

Probieren Sie es online!

• -20 Bytes, danke an Kevin Cruijssen

Java 8, 194 188 196 237 236 Bytes

n->s->{double r[]=new double[n+1],d[]=new double[n],t;int f=0,i=n,x=2*s>n?1:0;for(r[n]=s=x>0?n-s:s;f<1;){for(f=1;i-->1;)r[i]=Math.random()*s;for(java.util.Arrays.sort(r);i<n;d[i++]=x>0?1-t:t)f=(t=Math.abs(r[i]-r[i+1]))>1?0:f;}return d;}

+49-Bytes (188 → 196 und 196 → 237), um die Geschwindigkeit von Testfällen nahe 1 sowie den Algorithmus im Allgemeinen zu korrigieren.

Probieren Sie es online aus

Erläuterung:

Verwendet den Ansatz in dieser Stackoverflow Antwort , in einer Schleife solange eines des Elements ist noch größer als 1.
Auch wenn 2*s>n, swird in geändert werden n-s, und ein Flag gesetzt , um anzuzeigen , sollten wir verwenden , 1-diffanstatt diffim Ergebnis-Array (danke für den tipp @soktinpk und @ l4m2 ).

n->s->{              // Method with integer & double parameters and Object return-type
  double r[]=new double[n+1]
                     //  Double-array of random values of size `n+1`
         d[]=new double[n],
                     //  Resulting double-array of size `n`
         t;          //  Temp double
  int f=0,           //  Integer-flag (every item below 1), starting at 0
      i=n,           //  Index-integer, starting at `n`
      x=             //  Integer-flag (average below 0.5), starting at:
        2*s>n?       //   If two times `s` is larger than `n`:
         1           //    Set this flag to 1
        :            //   Else:
         0;          //    Set this flag to 0
  for(r[n]=s=        //  Set both the last item of `r` and `s` to:
       x>0?          //   If the flag `x` is 1:
        n-s          //    Set both to `n-s`
       :             //   Else:
        s;           //    Set both to `s`
      f<1;){         //  Loop as long as flag `f` is still 0
    for(f=1;         //   Reset the flag `f` to 1
        i-->1;)      //   Inner loop `i` in range (n,1] (skipping the first item)
      r[i]=Math.random()*s;
                     //    Set the i'th item in `r` to a random value in the range [0,s)
    for(java.util.Arrays.sort(r);
                     //   Sort the array `r` from lowest to highest
        i<n;         //   Inner loop `i` in the range [1,n)
        ;d[i++]=     //     After every iteration: Set the i'th item in `d` to:
          x>0?       //      If the flag `x` is 1:
           1-t       //       Set it to `1-t`
          :          //      Else:
           t)        //       Set it to `t`
      f=(t=Math.abs( //    Set `t` to the absolute difference of:
            r[i]-r[i+1])) 
                     //     The i'th & (i+1)'th items in `r`
        >1?          //    And if `t` is larger than 1 (out of the [0,1] boundary)
         0           //     Set the flag `f` to 0
        :            //    Else:
         f;}         //     Leave the flag `f` unchanged
  return d;}         //  Return the array `d` as result

JavaScript (Node.js) , 153 Byte

(n,s)=>s+s>n?g(n,n-s).map(r=>1-r):g(n,s)
g=(n,s)=>{do(a=[...Array(n-1)].map(_=>Math.random()*(s<1?s:1))).map(r=>t-=r,t=s);while(t<0|t>=1);return[...a,t]}

Probieren Sie es online!

C ++ 11, 284 267 Bytes

-17 Bytes dank Zacharý
Verwendet C ++ - Zufallsbibliothek, Ausgabe auf der Standardausgabe

#include<iostream>
#include<random>
typedef float z;template<int N>void g(z s){z a[N],d=s/N;int i=N;for(;i;)a[--i]=d;std::uniform_real_distribution<z>u(.0,d<.5?d:1-d);std::default_random_engine e;for(;i<N;){z c=u(e);a[i]+=c;a[++i]-=c;}for(;i;)std::cout<<a[--i]<<' ';}

Um anzurufen, müssen Sie nur das tun:

g<2>(0.0);

Wobei der Schablonenparameter (hier 2) N ist und der tatsächliche Parameter (hier 0,0) S ist

Sauber , 221 201 Bytes

Clean, Code-Golf oder Zufallszahlen. Suche dir zwei aus.

import StdEnv,Math.Random,System._Unsafe,System.Time
g l n s#k=toReal n
|s/k>0.5=[s/k-e\\e<-g l n(k-s)]
#r=take n l
#r=[e*s/sum r\\e<-r]
|all((>)1.0)r=r=g(tl l)n s

g(genRandReal(toInt(accUnsafe time)))

Probieren Sie es online!

Teilfunktionsliteral :: (Int Real -> [Real]). Erzeugt nur einmal pro Sekunde neue Ergebnisse.
Genauigkeit bis zu mindestens 10 Dezimalstellen.

R , 99 Bytes (mit gtoolsPaket)

f=function(n,s){if(s>n/2)return(1-f(n,n-s))
while(any(T>=1)){T=gtools::rdirichlet(1,rep(1,n))*s}
T}

Probieren Sie es online!

$\tilde{\mathcal A}=\{w_1,\ldots,w_n: \forall i, 0<w_i<1; \sum w_i=s\}$$w_i$$s$$\mathcal A=\{w_1,\ldots,w_n: \forall i, 0<w_i<\frac1s; \sum w_i=1\}$

$s=1$$Dirichlet(1, 1, \ldots, 1)$ $s\neq 1$$<1/s$$s$

$s>n/2$

C, 132 127 125 118 110 107 Bytes

-2 Bytes dank @ceilingcat

i;f(s,n,o,d)float*o,s,d;{for(i=n;i;o[--i]=d=s/n);for(;i<n;o[++i%n]-=s)o[i]+=s=(d<.5?d:1-d)*rand()/(1<<31);}

Probieren Sie es online!

Haskell , 122 217 208 Bytes

import System.Random
r p=randomR p
(n#s)g|n<1=[]|(x,q)<-r(max 0$s-n+1,min 1 s)g=x:((n-1)#(s-x)$q)
g![]=[]
g!a|(i,q)<-r(0,length a-1)g=a!!i:q![x|(j,x)<-zip[0..]a,i/=j]
n%s=uncurry(!).(n#s<$>).split<$>newStdGen

Probieren Sie es online!

Manchmal sind die Antworten aufgrund von Gleitkommafehlern etwas falsch. Wenn es ein Problem ist, kann ich es zu einem Preis von 1 Byte beheben. Ich bin mir auch nicht sicher, wie einheitlich das ist (ziemlich sicher, dass es in Ordnung ist, aber ich bin nicht so gut in so etwas), also beschreibe ich meinen Algorithmus.

Die Grundidee ist, eine Zahl zu generieren, sie xdann zu subtrahieren sund so lange zu wiederholen, bis wir nElemente haben, die wir dann mischen. Ich generiere xmit einer Obergrenze von 1 oder s(je nachdem, welcher Wert kleiner ist) und einer Untergrenze von s-n+1oder 0 (je nachdem, welcher Wert größer ist). Diese Untergrenze ist vorhanden, sodass sie bei der nächsten Iteration simmer noch kleiner oder gleich ist n(Herleitung: s-x<=n-1-> s<=n-1+x-> s-(n-1)<=x-> s-n+1<=x).

EDIT: Danke an @ michi7x7 für den Hinweis auf einen Fehler in meiner Uniformität. Ich glaube, ich habe es durch Mischen behoben, aber lass es mich wissen, wenn es ein anderes Problem gibt

EDIT2: Verbesserte Byteanzahl plus feste Typeinschränkung

Haskell , 188 Bytes

import System.Random
import Data.List
n!s|s>n/2=map(1-)<$>n!(n-s)|1>0=(zipWith(-)=<<tail).sort.map(*s).(++[0,1::Double])<$>mapM(\a->randomIO)[2..n]>>= \a->if all(<=1)a then pure a else n!s

Ungolfed:

n!s
 |s>n/2       = map (1-) <$> n!(n-s)       --If total more than half the # of numbers, mirror calculation 
 |otherwise   = (zipWith(-)=<<tail)        --Calculate interval lengths between consecutive numbers
              . sort                       --Sort
              . map(*s)                    --Scale
              . (++[0,1::Double])          --Add endpoints
              <$> mapM(\a->randomIO)[2..n] --Calculate n-1 random numbers
              >>= \a->if all(<=1)a then pure a else n!s   --Retry if a number was too large

Probieren Sie es online!