Dividieren eine Zahl in m Teile gleichmäßig zufällig

Question

Wie teilen wir eine große positive ganze Zahl n in m Teile gleichmäßig zufällig. Nachbedingung: Die Summe aller m Teile sollte n ergeben.

Unten ist mein Versuch (in Java wie Pseudocode), aber ich denke nicht, dass es mir gleichmäßig zufällige Verteilung geben wird. Ich finde zuerst den Durchschnittsteil Durchschnitt durch Division von n/m. Dann bin ich m-1 Zufallszahlen zu erzeugen, die um avg in der Größe sind (durch abwechselndes Erzeugen von Zufallszahlen zwischen 0 & avg und * avg & 2 * avg *. Dann habe ich die Summe dieser am Subtrahieren m- 1 Zahlen von ursprünglichen Anzahl n und Einstellung, die als m -te Teil.

Es sei angenommen, dass die Funktion rand (x, y) eine Zufallszahl gleichmßig zwischen x und y zurückgibt.

int[] divideUniformlyRandomly(int n, int m) 
{ 
    int[] res = new int[m]; 
    int avg = n/m; 
    int sum = 0; 
    bool alternator = false; 
    for(int i = 0; i < m - 1; i++) 
    { 
     if(alternator == false) 
     { 
      res[i] = rand(0, avg); 
      alternator = true; 
     } 
     else 
     { 
      res[i] = rand(avg, 2*avg); 
      alternator = false; 
     } 
     sum += res[i]; 
    } 
    res[m-1] = n - sum; 
    return res; 
} 

Answer 1

public double[] divideUniformlyRandomly(double number, int part) { 
    double uniformRandoms[] = new double[part]; 
    Random random = new Random(); 

    double mean = number/part; 
    double sum = 0.0; 

    for (int i=0; i<part/2; i++) { 
     uniformRandoms[i] = random.nextDouble() * mean; 

     uniformRandoms[part - i - 1] = mean + random.nextDouble() * mean; 

     sum += uniformRandoms[i] + uniformRandoms[part - i -1]; 
    } 
    uniformRandoms[(int)Math.ceil(part/2)] = uniformRandoms[(int)Math.ceil(part/2)] + number - sum; 

    return uniformRandoms; 
} 

Answer 2

Sie sollten n in m Teile unter Verwendung von m - 1 einheitlich verteilte Zäune teilen. Der Code könnte sein:

int[] divideUniformlyRandomly(int n, int m) 
{ 
    int[] fences = new int[m-1]; 
    for(int i = 0; i < m - 2; i++) 
    { 
     fences[i] = rand(0, n-1); 
    } 
    Arrays.sort(fences); 

    int[] result = new int[m]; 
    result[0] = fences[0]; 
    for(int i = 1; i < m - 2; i++) 
    { 
     result[i] = fences[i+1] - fences[i]; 
    } 
    result[m-1] = n - 1 - fences[m-2]; 

    return result; 
} 

Um dies zu veranschaulichen: