Generate random numbers that result in a fixed sum

Question

I need to generate random values for the inputs text of my table (remembering that it can have N lines), my code today can generate the numbers but I need the generated number to be at most X so that it does not exceed the value of the column Max.

Ex: If the total is 200, the maximum value of test 1 is 150 and test 2 is 130, the numbers must be generated so that the first value (test 1) is at most 150 and the second (test 2) at most 130 the sum totals 200.

If the sum of the maximum values is not sufficient to arrive at the entered value, return the highest possible value for each field.

Someone sees a practical solution to this case?

Jsfiddle

Answer 1

The algorithm proposed in my another answer is functional but it’s not righteous (i.e. does not distribute the value evenly between lines). If there are many lines, the latter tend to be all with 0. If there are few, the latter tend to get very large values. I will propose an alternative solution, limited to the case where the number to be distributed is whole and not excessively large, based on the "roulette" of genetic algorithms:

• Once again, you have 200 (which I will call alvo) to be distributed between N lines. For simplification, this time let’s assume that the lines have no minimum, only maximum (if you have, refer to the first part of my other answer to a means of distributing the minimum).
• Let’s make a loop in which at each iteration one of the lines will be chosen and receive 1 more. That is, the loop will execute 200 iterations.
  • A "roulette" is first created in which the area of each line in the roulette is proportional to its maximum value.
  • Then draw a line at roulette; add the value of 1 and reduces its maximum also in 1. If it reaches zero, the roulette area intended for that line will become zero and it will no longer be drawn.

Example:

var alvo = 200;
var linhas = [{min: 0, max: 150}, {min:0, max: 130}];
var resultado = [0, 0];

function criarRoleta() {
    var ret = [];
    var soma = 0;
    for ( var i = 0 ; i < linhas.length ; i++ ) {
        var valor = linhas[i].max - resultado[i];
        ret.push(valor+soma);
        soma += valor;
    }
    return [ret,soma];
}

for ( var i = 0 ; i < alvo ; i++ ) {
    var roleta = criarRoleta();
    var sorteio = Math.floor(Math.random()*roleta[1]);
    for ( var t = 0 ; t < linhas.length ; t++ )
        if ( sorteio < roleta[0][t] ) {
            resultado[t]++;
            break;
        }
}

Example in jsFiddle. Note that in this case the distribution tends to be uniform, and proportional to the maximum of each line. Extreme distributions are possible, but rare - the fact that lines already drawn have their areas reduced contributes to the other lines increase their chance of being chosen in the following rounds.

Updating: this method is equivalent to opening an urn, putting in it N balls of different colors (1 for each space available in each row), and go out removing balls until you reach the total. That is, the probability of each line being drawn changes during the draw, so that it is more likely that they will all be X% full than a 100% full and other more empty.

If on the other hand what you care about is that the chance of the elements falling on a line is proportional to the size initial of each line, then it is necessary to "put the drawn balls back into the urn": this is done by creating the roulette once, instead of recreating them at each iteration (i.e. move the call to criarRoleta() out of the loop). In this case, it is necessary to verify at each draw whether a line has reached its maximum and - if it has - "remove all the balls from that line from the urn" (i.e. upgrade the roulette so that the area of that line is zero, and the sum is adjusted accordingly).

Answer 2

I think you should approach the problem from another angle: you actually have 200 (I’ll call it alvo) and wants distribute that alvo for N lines, each line being subject to a maximum and perhaps a minimum. My suggestion then is:

• Deducts from its value (alvo) each of the minimum, and distribute between the lines (in your case there is no minimum, then the value continues 200 and each line continues with 0).
• For each line i table:
  • Calculate a minimo = alvo - soma(maximos[i+1:]); i.e. what fraction of this alvo must necessarily be on that line because if it is not will exceed the maximum of the other lines.
  • Draw a number between minimo and min(alvo, maximos[i]); assigns this value to the line and subtracts from the alvo.

Example:

var alvo = 200;
var linhas = [{min: 0, max: 150}, {min:0, max: 130}];
var resultado = [];

// Atribuindo os mínimos
for ( var i = 0 ; i < linhas.length ; i++ ) {
    resultado[i] = linhas[i].min;
    alvo -= linhas[i].min;
}

for ( var i = 0 ; i < linhas.length ; i++ ) {
    // o máximo que pode ser distribuído entre as linhas restantes
    var somaMax = 0;
    for ( var t = i+1 ; t < linhas.length ; t++ )
        somaMax += (linhas[t].max - linhas[t].min);

    // mínimo e máximo para esta linha
    var minimo = alvo < somaMax ? 0 : alvo - somaMax;
    var maximo = Math.min(alvo, linhas[i].max - linhas[i].min);

    // sorteia e atualiza o alvo
    var valor = Math.floor(Math.random()*(maximo-minimo) + minimo);
    resultado[i] += valor;
    alvo -= valor;
}

Example in jsFiddle.

Answer 3

Seeing at w3schools I saw that to set a range for Random and javascript you need to use:

Math.floor((Math.random()*100)+1); 

So you can create a function to do this using the maximum and minimum values as parameters like this

function randomRange(min, max){
    return Math.floor((Math.random() * max) + min);
}

And use it this way:

randomRange(150,1000);
randomRange($("#inputMinimo").val(),$("#inputMaximo").val());

Answer 4

Math.ceil((Math.random()*50)); // Onde 50 é o valor máximo (vai gerar números entre 0 e 50)