массив, распределение суммы как можно более равномерно

[рони]

Вариант решения ниже, не очень оптимальный, подскажите любое другое решение.

var input = [5,10,0,12], //массив лимита каждой ячейки
    total = 7, // сумма которую надо распределить равномерно
    output = [];// результат распределения
//total = 7 => output = [2,2,0,3]
//total = 20 => output = [5,7,0,8]
//total = 40 => output = [5,10,0,12]
function fn(input, total, output) {
    for (var i = 0; total; i = ++i % input.length) {
        output[i] = output[i] || 0;
        if (output[i] + 1 > input[i]) continue;
        output[i]++;
        total--
    }
    return output
};

console.log(fn(input, total, output))//[3, 2, 0, 2]

[j0hnik]

Ровнее только с плавающей точкой.

[рони]

j0hnik,
все числа целые, требуется оптимизация, желательно 1 проход по массиву или 2 - 3, а не как сейчас, пока сумма по 1 не уменьшится до конца.

[рони]

j0hnik,
что-то типа

output[i] = Math.floor(total/input.length)

[EmperioAf]

function fn(input, total) {
  const output = [];
  const order = input.map((_, index) => index);
  const sortedOrder = order.sort((a, b) => input[b] - input[a]);
  const mustCheckIndexes = [];
  for (let i = 0; i < sortedOrder.length; i++) {
    const sortedIndex = sortedOrder[i];
    if (i === 0) {
      mustCheckIndexes.push(sortedIndex);
    } else if (input[sortedIndex] === input[sortedOrder[i - 1]]) mustCheckIndexes.push(sortedIndex);
    else break;
  }
  for (let i = 0; total; i = ++i % input.length) {
    let breakCycle = false;
    for (const mustCheckIndex of mustCheckIndexes) {
      if (output[mustCheckIndex] === input[mustCheckIndex]) breakCycle = true;
      else breakCycle = false;
    }
    if (breakCycle) break;
    const currIndex = sortedOrder[i];
    output[currIndex] = output[currIndex] || 0;
    if (output[currIndex] + 1 > input[currIndex]) {
      continue;
    }
    output[currIndex]++;
    total--
  }
  return output
};

[j0hnik]

рони,
придумал разве что проверку добавить

if(input.reduce((c,e)=> e+c) <= total) return output = [...input];

больше ничего.

[Rise]

рони,
у вас получается бесконечный цикл, когда total больше суммы элементов input.

[рони]

EmperioAf,
спасибо, попробую разобраться
j0hnik,
Rise,
спасибо, да я в курсе когда total больше суммы -- выше был минимальный пример.

[Белый шум]

output[i] = Math.floor(total/input.length)

Так и делай, только floor лучше заменить на ceil.

var input = [5,10,0,12], //массив лимита каждой ячейки
    total = 7, // сумма которую надо распределить равномерно
    output = [];// результат распределения
//total = 7 => output = [2,2,0,3]
//total = 20 => output = [5,7,0,8]
//total = 40 => output = [5,10,0,12]

function allocate(input, total, output) {
  var rest = total; //остаток
  var quotient = Math.ceil(total/input.length); //частное
  var waste_count = 0; //счётчик превышений
  for( var i = 0; i < input.length; i++ ){
    output[i] = output[i] || 0;
    output[i] += quotient;
    rest -= quotient;
    if( output[i] > input[i] ) {
      var waste = output[i] - input[i];
      output[i] -= waste;
      rest += waste;
      waste_count++;
    }
    if( rest <= 0 ) {
      output[i] += rest;
      break;
    }
  }
//console.log(waste_count, rest, quotient);
  if( waste_count == input.length ) return output;
  if( rest > 0 ) return allocate(input, rest, output);
  return output;
}

console.log( allocate(input, 7, []) );
console.log( allocate(input, 20, []) );
console.log( allocate(input, 40, []) );

[рони]

Белый шум,
спасибо!