c# - repetir - generar numeros aleatorios en java del 1 al 100

¿Cómo generar tres números aleatorios, cuya suma es 1?

Question

Necesito generar 3 números aleatorios, cuya cantidad es igual a 1.

Mi implementación no admite distribución uniforme. :(

Answer 1

Ligera variación en la respuesta de Marnix:

1. Genera un número aleatorio a desde [0,1]
2. Genera dos números aleatorios. x de [0, a] e y de [a, 1]
3. Establecer resultados como x , yx , 1-y

Answer 2

Simplemente obtenga 3 números aleatorios y luego calcule un factor que sea 1 / [suma de sus números]. Finalmente, multiplica cada uno de los números aleatorios con ese factor. La suma será 1.

Answer 3

ACTUALIZAR

1. Crea un vector3 de 3 números aleatorios
2. Normaliza el vector

Answer 4

Esta es en realidad una pregunta difícil. Ante todo:
La solución de Daren no es uniforme porque no admite tener dos números> 1/3.
La solución de Simen no es uniforme, suponiendo que el "escoger un número aleatorio" se basa en una distribución uniforme, pero esto es un poco más sutil. Es al menos simétrico entre las variables (es decir, la probabilidad de [a, b, c] es la misma que la de cualquier permutación de eso), pero favorece fuertemente las soluciones más cercanas a (1/3, 1/3, 1 / 3). Piénselo de esta manera al observar casos extremos: (1/3, 1/3, 1/3) podría haber venido de cualquiera (a, a, a), donde varíe de 0 a 1. (1, 0, 0), un triple igualmente válido, debe provenir de (1, 0, 0).

Una solución: el conjunto de números positivos que se suman a 1 forman un triángulo equilátero en tres espacios, con coordenadas (1,0,0), (0,1,0), (0,0,1). Extiéndalo a un paralelogramo, por ejemplo, agregando un punto (1,1, -1) como cuarto punto. Este doble es el área: asigna la segunda área a la primera, de modo que sea suficiente para elegir un punto al azar en este paralelogramo.

El paralelogramo se puede muestrear uniformemente a través de (0,0,1) + A (1,0, -1) + B (0,1, -1), donde A y B varían uniformemente de 0 a 1.

-UN

Answer 5

Genera dos números aleatorios entre 0 y 1. Divide cada uno entre 3. El tercero es la diferencia de 1 y los dos tercios al azar:

void Main()
{
    Random r = new Random();
    double d1 = r.NextDouble() / 3.0;
    double d2 = r.NextDouble() / 3.0;
    double d3 = 1.0 - d1 - d2;
    System.Console.WriteLine(d1);
    System.Console.WriteLine(d2);
    System.Console.WriteLine(d3);
    System.Console.WriteLine(d1 + d2 + d3);
}

esto produce lo siguiente en LINQPad:

0.0514050276878934
0.156857372489847
0.79173759982226
1

Answer 6

Hay una manera fácil de hacerlo, pero debe ser capaz de generar un número aleatorio uniforme.

Deje que X sea uniforme en (0,2 / 3). Si X <1/3, deje Y = X + 1/3. De lo contrario, deje que Y = X - 1/3. Deje Z = 1 - X - Y.

Bajo esta configuración, X, Y y Z sumarán a 1, todos tendrán distribuciones marginales uniformes (0, 2/3) idénticas, y las tres correlaciones de pares serán - (1/2).

Answer 7

1/2 métodos:

• Crea una lista de números aleatorios, cada 0 a 1 de longitud PIEZAS.
• Suma la lista
• Divida cada elemento por la suma
• Redondea cada elemento
• Cuenta para matemática de punto flotante editando el primer elemento

Lo siento, no sé C #, aquí está la pitón:

import random
import time

PARTS       = 5
TOTAL       = 10
PLACES      = 3

def random_sum_split(parts, total, places):

    a = []
    for n in range(parts):
        a.append(random.random())
    b = sum(a)
    c = [x/b for x in a]    
    d = sum(c)
    e = c
    if places != None:
        e = [round(x*total, places) for x in c]
    f = e[-(parts-1):]
    g = total - sum(f)
    if places != None:
        g = round(g, places)
    f.insert(0, g)

    log(a)
    log(b)
    log(c)
    log(d)
    log(e)
    log(f)
    log(g)

    return f   

def tick():

    if info.tick == 1:

        start = time.time()

        alpha = random_sum_split(PARTS, TOTAL, PLACES)

        log(''********************'')
        log(''***** RESULTS ******'')
        log(''alpha: %s'' % alpha)
        log(''total: %.7f'' % sum(alpha))
        log(''parts: %s'' % PARTS)
        log(''places: %s'' % PLACES)

        end = time.time()  

        log(''elapsed: %.7f'' % (end-start))

yeilds:

Waiting...
Saved successfully.
[2014-06-13 00:01:00] [0.33561018369775897, 0.4904215932650632, 0.20264927800402832, 0.118862130636748, 0.03107818050878819]
[2014-06-13 00:01:00] 1.17862136611
[2014-06-13 00:01:00] [0.28474809073311597, 0.41609766067850096, 0.17193755673414868, 0.10084844382959707, 0.02636824802463724]
[2014-06-13 00:01:00] 1.0
[2014-06-13 00:01:00] [2.847, 4.161, 1.719, 1.008, 0.264]
[2014-06-13 00:01:00] [2.848, 4.161, 1.719, 1.008, 0.264]
[2014-06-13 00:01:00] 2.848
[2014-06-13 00:01:00] ********************
[2014-06-13 00:01:00] ***** RESULTS ******
[2014-06-13 00:01:00] alpha: [2.848, 4.161, 1.719, 1.008, 0.264]
[2014-06-13 00:01:00] total: 10.0000000
[2014-06-13 00:01:00] parts: 5
[2014-06-13 00:01:00] places: 3
[2014-06-13 00:01:00] elapsed: 0.0054131

Answer 8

2/2 métodos:

• Crea una lista de números aleatorios de 0 a 1; escalado al total
• Ordene la lista de pequeña a grande
• Crea una nueva lista midiendo el espacio entre cada elemento en la primera lista
• Redondea cada elemento en la nueva lista
• Reemplace el primer elemento para tener en cuenta el punto flotante

Lo siento, no sé C # esto es lo que parece en Python:

import random
import time

PARTS       = 5
TOTAL       = 10
PLACES      = 3

def random_sum_split(parts, total, places):


    a = [0.0, total]
    for i in range(parts-1):
        a.append(random.random()*total)
    a.sort()
    b = []
    for i in range(1,(parts+1)):
        b.append(a[i] - a[i-1])
    if places != None:    
        b = [round(x, places) for x in b]  
    c = b[-(parts-1):]
    d = total - sum(c)
    if places != None:
        d = round(d, places)
    c.insert(0, d)

    log(a)
    log(b)
    log(c)
    log(d)

    return c

def tick():

    if info.tick == 1:

        start = time.time()

        alpha = random_sum_split(PARTS, TOTAL, PLACES)

        log(''********************'')
        log(''***** RESULTS ******'')
        log(''alpha: %s'' % alpha)
        log(''total: %.7f'' % sum(alpha))
        log(''parts: %s'' % PARTS)
        log(''places: %s'' % PLACES)

        end = time.time()  

        log(''elapsed: %.7f'' % (end-start))

Rendimientos:

Waiting...
Saved successfully.
[2014-06-13 00:01:00] [0.0, 1.3005056784596913, 3.0412441135728474, 5.218388755020509, 7.156425483589107, 10]
[2014-06-13 00:01:00] [1.301, 1.741, 2.177, 1.938, 2.844]
[2014-06-13 00:01:00] [1.3, 1.741, 2.177, 1.938, 2.844]
[2014-06-13 00:01:00] 1.3
[2014-06-13 00:01:00] ********************
[2014-06-13 00:01:00] ***** RESULTS ******
[2014-06-13 00:01:00] alpha: [1.3, 1.741, 2.177, 1.938, 2.844]
[2014-06-13 00:01:00] total: 10.0000000
[2014-06-13 00:01:00] parts: 5
[2014-06-13 00:01:00] places: 3
[2014-06-13 00:01:00] elapsed: 0.0036860