Какой библиотекой на Node.js можно воспользоваться для равномерного деления?

Question

[Алексей]

Всем привет!

Не знаю, как это правильно выразить "по-математически")

Суть задачи в следующем.
- есть некое (в общем случае) вещественное число
- есть целое число - кол-во разбиений
- есть некое ограничение - точность
Надо найти "равномерное" разбиение

Проще показать на примере
Исходное число - 20, кол-во разбиений - 3, точность разбиений - до целого
Подходящий результат - 6-7-7 (три целых числа, в сумме дают исходное). Варианты типа 5-7-8 не подойдут - у них разброс получается не совсем "равномерный"
Понятное дело, что, к примеру, число 18 на три "равномерных" разбиения делится без проблем - 6-6-6

Более сложный пример
Исходное число 27.8, кол-во разбиений - 4, точность - 0.1. Подходящий результат - 6.9-6.9-7.0-7.0

Точность - это не максимально допустимое отклонение между полученными числами, а максимальная (минимальная?) точность самих чисел. То есть при точности 0.1 не может быть число, к примеру, 2.75 - только 2.7 или 2.8

Подозреваю, что у этой задачи наверняка есть свое название и, соответственно, алгоритм расчета. Буду рад, если кто-то им поделится, но в идеале хотелось бы готовое решение на Node.js

Заранее спасибо за ответы

Comments

[Сергей Соколов]

Точность какая бывает? Привязана к десятичным знакам или вообще любая, например, 0.137 ?

[bask]

Я сталкивался с подобной задачей, когда рисовал собственные графики.
Если это оно, то могу поделиться решением

[Алексей]

Сергей Соколов, точность всегда "логарифмическая", т.е 1, 0.1, 0.001 и т.д. Степень десятки

bask, буду рад)

Answer 1

[index0h]

Довольно интересная задачка, тут конечно нужно еще кучу проверок сделать, но алгоримт может выглядеть примерно так: https://3v4l.org/DQRKq

Comments

[AngReload]

То же самое на JS

function partitionOfNumber(number, count, precision) {
  const minElement = Math.floor(number / precision / count);
  const countAdditionalElements = (number / precision) - count * minElement;

  const result = [];
  for (let i = 0; i < count; i++) {
    if (i < countAdditionalElements) {
        result[i] = (minElement + 1) * precision;
    } else {
        result[i] = minElement * precision;
    }
  }

  return result;
}

// пример использования
partitionOfNumber(29.5, 6, 0.01).map(n => n.toFixed(2));
// выведет [ '4.92', '4.92', '4.92', '4.92', '4.91', '4.91' ]

Что бы не появилось чисел типа 6.6000000000000005 значения массива форматируются в строки с помощью .map(n => n.toFixed(2));

[Сергей Соколов]

AngReload, и становятся строками

Answer 2

[Сергей Соколов]

Можно решить рекурсией.

На каждом шаге получаем очередное слагаемое, округляя результат к ближайшему в «сетке» с учётом точности. Для целых это выглядит так:

Math.round(20 / 3) === 7 // 7 занесли в массив результата
20 - 7 = 13 
// далее повторяем с 13 и делим уже на 3 - 1 === 2
Math.round(13 / 2) === 7 // 7 идёт в результат
13 - 7 === 6
// далее повторяем с 6 и делить надо бы на 2 - 1 === 1
// т.е. осталось одно число в результат. Просто вписываем туда остаток 6

С точностью надо умножать/делить на эту точность перед тем, как округлять к ближайшему целому. Но тут вылезают проблемы с точностью плавающей точки. Поэтому надо уточнить, какие могут быть значения точности: до опр. знака после запятой, или вообще любое значение типа 0.137456?

function split(n, divisor, q, result) {
  q = q || 1;
  result = result || [];
  const m = q * Math.round(n / divisor / q);
  result.push(m);
  n -= m;
  if( --divisor > 1) return split(n, divisor, q, result);
  else {
    result.push(n);
    return result.sort((a,b) => a - b); // сортировка по возрастанию, на всякий случай
  }
}


split(20, 3) // [6, 7, 7]
split(20, 3, 0.1) // [6.6000000000000005, 6.7, 6.7]
split(27.8, 4, 0.1) // [6.9, 6.9, 7, 7]