Su tarea es escribir un programa o una función que genere n números aleatorios del intervalo [0,1] con una suma fija s.

Entrada

n, n≥1, número de números aleatorios para generar

s, s>=0, s<=n, suma de números a generar

Salida

Una ntupla aleatoria de números de coma flotante con todos los elementos del intervalo [0,1] y la suma de todos los elementos iguales a s, salida de cualquier manera conveniente y sin ambigüedades. Todas las ntuplas válidas tienen que ser igualmente probables dentro de las limitaciones de los números de coma flotante.

Esto es igual al muestreo uniforme desde la intersección de los puntos dentro del ncubo de la unidad dimensional y el n-1hiperplano dimensional que atraviesa (s/n, s/n, …, s/n)y es perpendicular al vector (1, 1, …, 1)(ver el área roja en la Figura 1 para ver tres ejemplos).

Figura 1: El plano de salidas válidas con n = 3 y sumas 0.75, 1.75 y 2.75

Ejemplos

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]

Reglas

• Su programa debería terminar en menos de un segundo en su máquina al menos con n≤10y cualquier s válido.
• Si lo desea, su programa puede ser exclusivo en el extremo superior, es decir, s<ny los números de salida del intervalo medio abierto [0,1] (rompiendo el segundo ejemplo)
• Si su idioma no admite números de coma flotante, puede falsificar la salida con al menos diez dígitos decimales después del punto decimal.
• Las lagunas estándar no están permitidas y se permiten métodos de entrada / salida estándar.
• Este es el código de golf , por lo que gana la entrada más corta, medida en 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]&

Pruébalo en línea!

Código sin 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       *)

Aquí hay una solución que funciona en 55 bytes, pero por ahora (la versión 12 de Mathematica) está restringida a n=1,2,3porque se RandomPointniega a dibujar puntos de hiperplanos de dimensiones superiores (en la versión 11.3 de TIO también falla n=1). Sin nembargo, puede funcionar para más alto en el futuro:

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

Pruébalo en línea!

Código sin 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) , 122115 bytes

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

Pruébalo en línea!

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)

Pruébalo en línea!

• -20 bytes, gracias a 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 y 196 → 237) para corregir la velocidad de los casos de prueba que se acercan a 1, así como también arreglar el algoritmo en general.

Pruébalo en línea

Explicación:

Usa el enfoque de esta respuesta Stackoverflow , dentro de un bucle, siempre y cuando uno de los elementos es aún mayor que 1.
Además, si 2*s>n, sserá transformado en n-s, y se establece un indicador para indicar que debemos utilizar 1-diffen lugar de diffen el resultado de matriz (gracias por el consejo @soktinpk y @ 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 bytes

(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]}

Pruébalo en línea!

C ++ 11, 284 267 bytes

-17 bytes gracias a
la biblioteca aleatoria Zacharý Utiliza C ++, salida en la salida estándar

#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]<<' ';}

Para llamar, solo necesita hacer eso:

g<2>(0.0);

Donde el parámetro de plantilla (aquí, 2) es N, y el parámetro real (aquí, 0.0) es S

Limpio , 221 201 bytes

Limpio, código de golf o números aleatorios. Elige dos.

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

Pruébalo en línea!

Función parcial literal :: (Int Real -> [Real]). Solo producirá nuevos resultados una vez por segundo.
Preciso hasta al menos 10 decimales.

R , 99 bytes (con gtoolspaquete)

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}

Pruébalo en línea!

$\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 gracias a @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);}

Pruébalo en línea!

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

Pruébalo en línea!

A veces las respuestas están ligeramente desviadas debido, supongo, a un error de coma flotante. Si es un problema, puedo solucionarlo a un costo de 1 byte. Tampoco estoy seguro de qué tan uniforme es esto (bastante seguro de que está bien, pero no soy tan bueno en este tipo de cosas), así que describiré mi algoritmo.

La idea básica es generar un número, xluego restarlo sy repetirlo hasta que tengamos nelementos y luego mezclarlos. Genero xcon un límite superior de 1 o s(el que sea menor) y un límite inferior de s-n+1o 0 (el mayor). Ese límite inferior está ahí, de modo que en la próxima iteración sseguirá siendo menor o igual que n(derivación: s-x<=n-1-> s<=n-1+x-> s-(n-1)<=x-> s-n+1<=x).

EDITAR: Gracias a @ michi7x7 por señalar una falla en mi uniformidad. Creo que lo solucioné con barajar pero avíseme si hay otro problema

EDIT2: recuento de bytes mejorado más restricción de tipo fijo

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

Sin golf:

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

Pruébalo en línea!