Nhiệm vụ của bạn là viết một chương trình hoặc một chức năng mà kết quả đầu ra n số ngẫu nhiên từ khoảng [0,1] với số tiền cố định s.

Đầu vào

n, n≥1, số lượng số ngẫu nhiên để tạo

s, s>=0, s<=n, tổng số được tạo

Đầu ra

Một tập hợp ngẫu nhiên ncác số dấu phẩy động với tất cả các phần tử từ khoảng [0,1] và tổng của tất cả các phần tử bằng s, xuất ra theo bất kỳ cách rõ ràng thuận tiện nào. Tất cả các dữ liệu hợp lệ nphải có khả năng như nhau trong giới hạn của số dấu phẩy động.

Điều này tương đương với việc lấy mẫu thống nhất từ ​​giao điểm của các điểm bên trong nkhối đơn vị hai chiều và n-1siêu phẳng hai chiều đi qua (s/n, s/n, …, s/n)và vuông góc với vectơ (1, 1, …, 1)(xem khu vực màu đỏ trong Hình 1 để biết ba ví dụ).

Hình 1: Mặt phẳng của các đầu ra hợp lệ với n = 3 và tổng 0,75, 1,75 và 2,75

Ví dụ

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]

Quy tắc

• Chương trình của bạn sẽ kết thúc dưới một giây trên máy của bạn ít nhất là với n≤10bất kỳ s hợp lệ nào.
• Nếu bạn rất muốn, chương trình của bạn có thể là độc quyền ở đầu trên, tức là s<nvà các số đầu ra từ khoảng thời gian nửa mở [0,1) (phá vỡ ví dụ thứ hai)
• Nếu ngôn ngữ của bạn không hỗ trợ số dấu phẩy động, bạn có thể giả mạo đầu ra với ít nhất mười chữ số thập phân sau dấu thập phân.
• Các lỗ hổng tiêu chuẩn không được phép và các phương thức đầu vào / đầu ra tiêu chuẩn được cho phép.
• Đây là môn đánh gôn , vì vậy bài dự thi ngắn nhất, tính bằng byte, sẽ thắng.

Ngôn ngữ Wolfram (Mathicala) , 92 90 byte

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

Hãy thử trực tuyến!

Mã không chơi gôn:

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

Đây là một giải pháp hoạt động trong 55 byte nhưng hiện tại (Mathicala phiên bản 12) bị hạn chế n=1,2,3do RandomPointtừ chối rút điểm từ các siêu máy bay có chiều cao hơn (trong phiên bản 11.3 của TIO, nó cũng không thành công n=1). Nó có thể hoạt động cho cao hơn ntrong tương lai:

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

Hãy thử trực tuyến!

Mã không chơi gôn:

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

Hãy thử trực tuyến!

Python 2 , 144 128 119 byte

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)

Hãy thử trực tuyến!

• -20 byte, nhờ Kevin Cruijssen

Java 8, 194 188 196 237 236 byte

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 byte (188 → 196 và 196 → 237) để sửa tốc độ của các trường hợp kiểm tra gần 1, cũng như sửa thuật toán nói chung.

Dùng thử trực tuyến

Giải trình:

Sử dụng cách tiếp cận trong câu trả lời StackoverFlow này , bên trong một vòng lặp miễn là một trong các mục vẫn lớn hơn 1.
Ngoài ra, nếu 2*s>n, ssẽ được thay đổi thành n-svà một cờ được đặt để cho biết chúng ta nên sử dụng 1-diffthay vì difftrong mảng kết quả (cảm ơn vì tiền boa @soktinpk và @ 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]}

Hãy thử trực tuyến!

C ++ 11, 284 267 byte

-17 byte nhờ Zacharý
Sử dụng thư viện ngẫu nhiên C ++, đầu ra trên đầu ra tiêu chuẩn

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

Để gọi, bạn chỉ cần làm điều đó:

g<2>(0.0);

Trong đó tham số mẫu (ở đây, 2) là N và tham số thực tế (ở đây, 0,0) là S

Sạch sẽ , 221 201 byte

Sạch sẽ, mã golf, hoặc số ngẫu nhiên. Chọn hai.

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

Hãy thử trực tuyến!

Chức năng một phần theo nghĩa đen :: (Int Real -> [Real]). Sẽ chỉ tạo ra kết quả mới mỗi giây một lần.
Chính xác đến ít nhất 10 chữ số thập phân.

R , 99 byte (vớigtools gói)

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}

Hãy thử trực tuyến!

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

-2 byte nhờ @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);}

Hãy thử trực tuyến!

Haskell , 122 217 208 byte

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

Hãy thử trực tuyến!

Đôi khi, các câu trả lời hơi bị sai do, tôi cho rằng, lỗi dấu phẩy động. Nếu đó là một vấn đề tôi có thể sửa nó với chi phí 1 byte. Tôi cũng không chắc nó đồng nhất như thế nào (khá chắc chắn là nó ổn nhưng tôi không giỏi lắm với loại điều này), vì vậy tôi sẽ mô tả thuật toán của mình.

Ý tưởng cơ bản là tạo ra một số xsau đó trừ đi svà lặp lại cho đến khi chúng ta có ncác phần tử sau đó xáo trộn chúng. Tôi tạo ra xvới giới hạn trên là 1 hoặc s(tùy theo giá trị nào nhỏ hơn) và giới hạn dưới là s-n+10 (tùy theo giá trị nào lớn hơn). Giới hạn dưới đó là có để lần lặp tiếp theo svẫn sẽ nhỏ hơn hoặc bằng n(đạo hàm: s-x<=n-1-> s<=n-1+x-> s-(n-1)<=x-> s-n+1<=x).

EDIT: Cảm ơn @ michi7x7 vì đã chỉ ra một lỗ hổng trong tính đồng nhất của tôi. Tôi nghĩ rằng tôi đã sửa nó bằng cách xáo trộn nhưng hãy cho tôi biết nếu có vấn đề khác

EDIT2: Số byte được cải thiện cộng với hạn chế loại cố định

Haskell , 188 byte

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

Ung dung:

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

Hãy thử trực tuyến!