考虑下面四个百分比，用浮点数表示:
13.626332%
47.989636%
9.596008%
28.788024%
-----------
100.000000%
我需要用整数表示这些百分比。如果我简单地使用Math.round()，我最终得到的总数是101%。
14 + 48 + 10 + 29 = 101
如果我使用parseInt()，我最终得到了97%。
13 + 47 + 9 + 28 = 97
有什么好的算法可以将任何百分比数表示为整数，同时还保持总数为100%?
编辑:在阅读了一些评论和回答后，显然有很多方法可以解决这个问题。
在我看来，为了保持数字的真实性，“正确”的结果是最小化总体误差的结果，定义为相对于实际值会引入多少误差舍入:
value rounded error decision
----------------------------------------------------
13.626332 14 2.7% round up (14)
47.989636 48 0.0% round up (48)
9.596008 10 4.0% don't round up (9)
28.788024 29 2.7% round up (29)
在平局的情况下(3.33,3.33,3.33)可以做出任意的决定(例如3,4,3)。
您可以尝试跟踪由于舍入而产生的误差，如果累计误差大于当前数字的小数部分，则再反向舍入。
13.62 -> 14 (+.38)
47.98 -> 48 (+.02 (+.40 total))
9.59 -> 10 (+.41 (+.81 total))
28.78 -> 28 (round down because .81 > .78)
------------
100
不确定这是否适用于一般情况，但如果顺序相反，似乎也会有类似的效果:
28.78 -> 29 (+.22)
9.59 -> 9 (-.37; rounded down because .59 > .22)
47.98 -> 48 (-.35)
13.62 -> 14 (+.03)
------------
100
我相信在某些情况下，这种方法可能会失效，但任何方法都至少在某种程度上是任意的，因为您基本上是在修改输入数据。
因为这里没有一个答案似乎能正确解决这个问题，下面是我使用下划线的半模糊版本:
function foo(l, target) {
var off = target - _.reduce(l, function(acc, x) { return acc + Math.round(x) }, 0);
return _.chain(l).
sortBy(function(x) { return Math.round(x) - x }).
map(function(x, i) { return Math.round(x) + (off > i) - (i >= (l.length + off)) }).
value();
}
foo([13.626332, 47.989636, 9.596008, 28.788024], 100) // => [48, 29, 14, 9]
foo([16.666, 16.666, 16.666, 16.666, 16.666, 16.666], 100) // => [17, 17, 17, 17, 16, 16]
foo([33.333, 33.333, 33.333], 100) // => [34, 33, 33]
foo([33.3, 33.3, 33.3, 0.1], 100) // => [34, 33, 33, 0]
我用Javascript写了一个函数，它接受一个百分比数组，并使用最大余数方法输出一个四舍五入的百分比数组。它不使用任何库。
输入:[21.6,46.7,31,0.5,0.2]
输出:[22,47,31,0,0]
const values = [21.6, 46.7, 31, 0.5, 0.2];
console.log(roundPercentages(values));
function roundPercentages(values) {
const flooredValues = values.map(e => Math.floor(e));
const remainders = values.map(e => e - Math.floor(e));
const totalRemainder = 100 - flooredValues.reduce((a, b) => a + b);
// Deep copy because order of remainders is important
[...remainders]
// Sort from highest to lowest remainder
.sort((a, b) => b - a)
// Get the n largest remainder values, where n = totalRemainder
.slice(0, totalRemainder)
// Add 1 to the floored percentages with the highest remainder (divide the total remainder)
.forEach(e => flooredValues[remainders.indexOf(e)] += 1);
return flooredValues;
}
可能做到这一点的“最佳”方法(引用是因为“最佳”是一个主观术语)是保持你所处位置的连续(非积分)计数，并四舍五入该值。
然后将其与历史记录一起使用，以确定应该使用什么值。例如，使用您给出的值:
Value CumulValue CumulRounded PrevBaseline Need
--------- ---------- ------------ ------------ ----
0
13.626332 13.626332 14 0 14 ( 14 - 0)
47.989636 61.615968 62 14 48 ( 62 - 14)
9.596008 71.211976 71 62 9 ( 71 - 62)
28.788024 100.000000 100 71 29 (100 - 71)
---
100
在每个阶段，都不需要四舍五入数字本身。相反，将累积值四舍五入，并计算出从上一个基线中达到该值的最佳整数——该基线是前一行的累积值(四舍五入)。
这是可行的，因为您不会在每个阶段都丢失信息，而是更聪明地使用信息。“正确的”四舍五入值在最后一列，你可以看到它们的和是100。
在上面的第三个值中，您可以看到这与盲目舍入每个值之间的区别。虽然9.596008通常会四舍五入到10，但累积的71.211976正确地四舍五入到71 -这意味着只需要9就可以加上之前的基线62。
这也适用于“有问题的”序列，比如三个大约1/3的值，其中一个应该四舍五入:
Value CumulValue CumulRounded PrevBaseline Need
--------- ---------- ------------ ------------ ----
0
33.333333 33.333333 33 0 33 ( 33 - 0)
33.333333 66.666666 67 33 34 ( 67 - 33)
33.333333 99.999999 100 67 33 (100 - 67)
---
100
