小开

可能做到这一点的“最佳”方法(引用因为“最佳”是一个主观术语)是保持你所处位置的运行(非积分)计数，并舍入那值。

然后将其与历史记录一起使用，以确定应该使用什么值。例如，使用您给出的值:

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基线中。

这也适用于“有问题的”序列，比如三个大致为-¹/₃的值，其中的一个应该四舍五入:

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

小开

如果是四舍五入，就没有办法在所有情况下都得到完全相同的结果。

你可以取你拥有的N个百分比的小数部分(在你给出的例子中是4)。

把小数部分相加。在你的例子中，总分为3。

将分数最高的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

我相信在某些情况下，这种方法可能会失效，但任何方法都至少在某种程度上是任意的，因为您基本上是在修改输入数据。

小开

不要把四舍五入的数字相加。你会得到不准确的结果。总数可能会显著偏离，这取决于术语的数量和小数部分的分布。

显示是四舍五入的数字，而总和是实际值。根据你呈现数字的方式不同，实际的方法也会有所不同。这样你就能得到

不管怎样，都会有差异。在你的例子中，没有办法显示加起来等于100的数字而不以错误的方式“舍入”一个值(最小的错误是将9.596更改为9)

编辑

你需要在以下选项中做出选择:

项目的准确性
和的准确性(如果你是四舍五入的值)
四舍五入的项目与四舍五入的总和的一致性)

大多数情况下，当处理百分比时，第三种方法是最好的选择，因为当总数等于101%时比当单个项目的总数不等于100时更明显，并且您可以保持单个项目的准确性。“舍入”9.596到9在我看来是不准确的。

为了解释这一点，我有时会添加一个脚注，解释各个值是四舍五入的，可能不是100% -任何理解四舍五入的人都应该能够理解这个解释。

小开

只要您不关心对原始十进制数据的依赖，就有许多方法可以做到这一点。

第一个也是最流行的方法是最大余数法

基本上就是:

四舍五入
求sum和100的差值
将差值按小数部分的递减顺序加1

在你的例子中，它是这样的:

如果取整数部分，就得到

加起来是97，再加3。现在，你看小数点部分

.626332%
.989636%
.596008%
.788024%

取最大的，直到总数达到100。所以你会得到:

或者，您可以简单地选择显示一个小数位而不是整数值。所以数字是48.3和23.9等等。这会使方差从100下降很多。

小开

这是一个银行家四舍五入的例子，又名“四舍五入半偶数”。BigDecimal支持。它的目的是确保四舍五入平衡，即不偏袒银行或客户。

小开

我不确定你需要什么级别的精度，但我要做的是简单地添加1第n数字，n是小数点总和的上限。在这种情况下，它是3，所以我将在前3项中添加1，并对其余的项进行取整。当然，这并不是非常准确，有些数字可能会四舍五入或在不应该的时候，但它工作得很好，总是会得到100%。

因此，[ 13.626332, 47.989636, 9.596008, 28.788024 ]将是[14, 48, 10, 28]，因为Math.ceil(.626332+.989636+.596008+.788024) == 3

function evenRound( arr ) {
var decimal = -~arr.map(function( a ){ return a % 1 })
.reduce(function( a,b ){ return a + b }); // Ceil of total sum of decimals
for ( var i = 0; i < decimal; ++i ) {
arr[ i ] = ++arr[ i ]; // compensate error by adding 1 the the first n items
}
return arr.map(function( a ){ return ~~a }); // floor all other numbers
}


var nums = evenRound( [ 13.626332, 47.989636, 9.596008, 28.788024 ] );
var total = nums.reduce(function( a,b ){ return a + b }); //=> 100

你总是可以告诉用户这些数字是四舍五入的，可能不是非常准确……

小开

我曾经写过一个un舍入工具，来找到一组数字的最小扰动来匹配一个目标。这是一个不同的问题，但理论上可以在这里使用类似的想法。在这种情况下，我们有一系列的选择。

因此，对于第一个元素，我们可以四舍五入到14，也可以四舍五入到13。这样做的代价(在二进制整数编程的意义上)对于向上舍入比向下舍入要小，因为向下舍入需要我们将该值移动更大的距离。同样，我们可以把每个数字四舍五入，所以我们总共有16个选择。

  13.626332
47.989636
9.596008
+ 28.788024
-----------
100.000000

我通常会在MATLAB中使用bintprog(一种二进制整数编程工具)解决一般问题，但这里只有几个选项需要测试，所以用简单的循环就可以很容易地测试出16个选项中的每一个。例如，假设我们将这个集合四舍五入为:

 Original      Rounded   Absolute error
13.626           13          0.62633
47.99           48          0.01036
9.596           10          0.40399
+ 28.788           29          0.21198
---------------------------------------
100.000          100          1.25266

总绝对误差为1.25266。它可以通过以下替代舍入来略微减少:

 Original      Rounded   Absolute error
13.626           14          0.37367
47.99           48          0.01036
9.596            9          0.59601
+ 28.788           29          0.21198
---------------------------------------
100.000          100          1.19202

事实上，这就是绝对误差的最优解。当然，如果有20项，搜索空间的大小将是2^20 = 1048576。对于30或40个术语，这个空间将是相当大的。在这种情况下，您将需要使用能够有效搜索空间的工具，可能使用分支和绑定方案。

小开

我认为以下几点可以达到你的目的

function func( orig, target ) {


var i = orig.length, j = 0, total = 0, change, newVals = [], next, factor1, factor2, len = orig.length, marginOfErrors = [];


// map original values to new array
while( i-- ) {
total += newVals[i] = Math.round( orig[i] );
}


change = total < target ? 1 : -1;


while( total !== target ) {


// Iterate through values and select the one that once changed will introduce
// the least margin of error in terms of itself. e.g. Incrementing 10 by 1
// would mean an error of 10% in relation to the value itself.
for( i = 0; i < len; i++ ) {


next = i === len - 1 ? 0 : i + 1;


factor2 = errorFactor( orig[next], newVals[next] + change );
factor1 = errorFactor( orig[i], newVals[i] + change );


if(  factor1 > factor2 ) {
j = next;
}
}


newVals[j] += change;
total += change;
}




for( i = 0; i < len; i++ ) { marginOfErrors[i] = newVals[i] && Math.abs( orig[i] - newVals[i] ) / orig[i]; }


// Math.round() causes some problems as it is difficult to know at the beginning
// whether numbers should have been rounded up or down to reduce total margin of error.
// This section of code increments and decrements values by 1 to find the number
// combination with least margin of error.
for( i = 0; i < len; i++ ) {
for( j = 0; j < len; j++ ) {
if( j === i ) continue;


var roundUpFactor = errorFactor( orig[i], newVals[i] + 1)  + errorFactor( orig[j], newVals[j] - 1 );
var roundDownFactor = errorFactor( orig[i], newVals[i] - 1) + errorFactor( orig[j], newVals[j] + 1 );
var sumMargin = marginOfErrors[i] + marginOfErrors[j];


if( roundUpFactor < sumMargin) {
newVals[i] = newVals[i] + 1;
newVals[j] = newVals[j] - 1;
marginOfErrors[i] = newVals[i] && Math.abs( orig[i] - newVals[i] ) / orig[i];
marginOfErrors[j] = newVals[j] && Math.abs( orig[j] - newVals[j] ) / orig[j];
}


if( roundDownFactor < sumMargin ) {
newVals[i] = newVals[i] - 1;
newVals[j] = newVals[j] + 1;
marginOfErrors[i] = newVals[i] && Math.abs( orig[i] - newVals[i] ) / orig[i];
marginOfErrors[j] = newVals[j] && Math.abs( orig[j] - newVals[j] ) / orig[j];
}


}
}


function errorFactor( oldNum, newNum ) {
return Math.abs( oldNum - newNum ) / oldNum;
}


return newVals;
}




func([16.666, 16.666, 16.666, 16.666, 16.666, 16.666], 100); // => [16, 16, 17, 17, 17, 17]
func([33.333, 33.333, 33.333], 100); // => [34, 33, 33]
func([33.3, 33.3, 33.3, 0.1], 100); // => [34, 33, 33, 0]
func([13.25, 47.25, 11.25, 28.25], 100 ); // => [13, 48, 11, 28]
func( [25.5, 25.5, 25.5, 23.5], 100 ); // => [25, 25, 26, 24]

最后一件事，我使用问题中最初给出的数字运行函数，与期望的输出进行比较

func([13.626332, 47.989636, 9.596008, 28.788024], 100); // => [48, 29, 13, 10]

这与问题想要的不同=>[48,29,14,9]。我无法理解这一点，直到我看了总误差范围

-------------------------------------------------
| original  | question | % diff | mine | % diff |
-------------------------------------------------
| 13.626332 | 14       | 2.74%  | 13   | 4.5%   |
| 47.989636 | 48       | 0.02%  | 48   | 0.02%  |
| 9.596008  | 9        | 6.2%   | 10   | 4.2%   |
| 28.788024 | 29       | 0.7%   | 29   | 0.7%   |
-------------------------------------------------
| Totals    | 100      | 9.66%  | 100  | 9.43%  |
-------------------------------------------------

从本质上讲，我的函数的结果实际上引入了最少的误差。

小提琴在这里

小开

最佳答案

由于这里的答案似乎都不能正确地解决它，下面是我使用underscorejs的半混淆版本:

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]

小开

我写了一个c#版本的舍入帮助器，算法和Varun Vohra的回答是一样，希望对大家有帮助。

public static List<decimal> GetPerfectRounding(List<decimal> original,
decimal forceSum, int decimals)
{
var rounded = original.Select(x => Math.Round(x, decimals)).ToList();
Debug.Assert(Math.Round(forceSum, decimals) == forceSum);
var delta = forceSum - rounded.Sum();
if (delta == 0) return rounded;
var deltaUnit = Convert.ToDecimal(Math.Pow(0.1, decimals)) * Math.Sign(delta);


List<int> applyDeltaSequence;
if (delta < 0)
{
applyDeltaSequence = original
.Zip(Enumerable.Range(0, int.MaxValue), (x, index) => new { x, index })
.OrderBy(a => original[a.index] - rounded[a.index])
.ThenByDescending(a => a.index)
.Select(a => a.index).ToList();
}
else
{
applyDeltaSequence = original
.Zip(Enumerable.Range(0, int.MaxValue), (x, index) => new { x, index })
.OrderByDescending(a => original[a.index] - rounded[a.index])
.Select(a => a.index).ToList();
}


Enumerable.Repeat(applyDeltaSequence, int.MaxValue)
.SelectMany(x => x)
.Take(Convert.ToInt32(delta/deltaUnit))
.ForEach(index => rounded[index] += deltaUnit);


return rounded;
}

通过以下单元测试:

[TestMethod]
public void TestPerfectRounding()
{
CollectionAssert.AreEqual(Utils.GetPerfectRounding(
new List<decimal> {3.333m, 3.334m, 3.333m}, 10, 2),
new List<decimal> {3.33m, 3.34m, 3.33m});


CollectionAssert.AreEqual(Utils.GetPerfectRounding(
new List<decimal> {3.33m, 3.34m, 3.33m}, 10, 1),
new List<decimal> {3.3m, 3.4m, 3.3m});


CollectionAssert.AreEqual(Utils.GetPerfectRounding(
new List<decimal> {3.333m, 3.334m, 3.333m}, 10, 1),
new List<decimal> {3.3m, 3.4m, 3.3m});




CollectionAssert.AreEqual(Utils.GetPerfectRounding(
new List<decimal> { 13.626332m, 47.989636m, 9.596008m, 28.788024m }, 100, 0),
new List<decimal> {14, 48, 9, 29});
CollectionAssert.AreEqual(Utils.GetPerfectRounding(
new List<decimal> { 16.666m, 16.666m, 16.666m, 16.666m, 16.666m, 16.666m }, 100, 0),
new List<decimal> { 17, 17, 17, 17, 16, 16 });
CollectionAssert.AreEqual(Utils.GetPerfectRounding(
new List<decimal> { 33.333m, 33.333m, 33.333m }, 100, 0),
new List<decimal> { 34, 33, 33 });
CollectionAssert.AreEqual(Utils.GetPerfectRounding(
new List<decimal> { 33.3m, 33.3m, 33.3m, 0.1m }, 100, 0),
new List<decimal> { 34, 33, 33, 0 });
}

小开

舍入的目标是产生最少的错误。当您对单个值进行舍入时，这个过程简单而直接，大多数人都很容易理解。当你同时四舍五入多个数字时，这个过程变得更加棘手——你必须定义如何组合错误，即必须最小化的错误。

Varun Vohra的回答很受欢迎最小化了绝对误差的总和，它的实现非常简单。然而，有一些边缘情况它不能处理-舍入24.25, 23.25, 27.25, 25.25的结果应该是什么?其中一个需要被围捕，而不是减少。你可能会任意选择列表中的第一个或最后一个。

也许使用相对错误比使用绝对错误更好。将23.25四舍五入到24会使它变化3.2%，而将27.25四舍五入到28只会使它变化2.8%。现在有一个明显的赢家。

我们还可以做进一步的调整。一种常见的技术是广场每个错误，这样大错误的计数比小错误不成比例地多。我还会使用非线性除数来得到相对误差——1%的误差比99%的误差重要99倍，这似乎是不对的。在下面的代码中，我使用了平方根。

完整算法如下:

将这些百分比四舍五入后相加，再减去100。这将告诉您这些百分比中有多少必须四舍五入。
为每个百分比生成两个错误分数，一个是四舍五入，另一个是四舍五入。取两者之差。
对上面产生的误差差异进行排序。
对于需要四舍五入的百分比数，从已排序的列表中选取一项，并将四舍五入后的百分比增加1。

你仍然可以有多个具有相同错误和的组合，例如33.3333333, 33.3333333, 33.3333333。这是不可避免的，结果完全是任意的。下面给出的代码倾向于四舍五入左边的值。

在Python中把它们放在一起是这样的。

from math import isclose, sqrt


def error_gen(actual, rounded):
divisor = sqrt(1.0 if actual < 1.0 else actual)
return abs(rounded - actual) ** 2 / divisor


def round_to_100(percents):
if not isclose(sum(percents), 100):
raise ValueError
n = len(percents)
rounded = [int(x) for x in percents]
up_count = 100 - sum(rounded)
errors = [(error_gen(percents[i], rounded[i] + 1) - error_gen(percents[i], rounded[i]), i) for i in range(n)]
rank = sorted(errors)
for i in range(up_count):
rounded[rank[i][1]] += 1
return rounded


>>> round_to_100([13.626332, 47.989636, 9.596008, 28.788024])
[14, 48, 9, 29]
>>> round_to_100([33.3333333, 33.3333333, 33.3333333])
[34, 33, 33]
>>> round_to_100([24.25, 23.25, 27.25, 25.25])
[24, 23, 28, 25]
>>> round_to_100([1.25, 2.25, 3.25, 4.25, 89.0])
[1, 2, 3, 4, 90]

正如您在最后一个示例中看到的，该算法仍然能够提供非直观的结果。尽管89.0不需要四舍五入，但是列表中的一个值需要四舍五入;相对误差最小的结果是将较大的值舍入，而不是较小的可选值。

这个答案最初主张遍历所有可能的向上舍入/向下舍入组合，但正如评论中指出的那样，更简单的方法效果更好。算法和代码反映了这种简化。

小开

如果你真的必须四舍五入，这里已经有了很好的建议(最大余数，最小相对误差，等等)。

也有一个很好的理由不四舍五入(你至少会得到一个“看起来更好”但“错误”的数字)，以及如何解决这个问题(警告你的读者)，这就是我所做的。

让我加上“错误”的数字部分。

假设你有三个事件/实体/…用一些百分比来近似:

DAY 1
who |  real | app
----|-------|------
A | 33.34 |  34
B | 33.33 |  33
C | 33.33 |  33

稍后，值略有变化，为

DAY 2
who |  real | app
----|-------|------
A | 33.35 |  33
B | 33.36 |  34
C | 33.29 |  33

第一个表有前面提到的“错误”数字的问题:33.34更接近33而不是34。

但现在误差更大了。与第2天和第1天相比，A的实际百分比值增加了0.01%，但近似值显示下降了1%。

这是一个定性错误，可能比最初的定量错误更严重。

你可以为整个集合设计一个近似值，但是，你可能必须在第一天发布数据，因此你不知道第二天的情况。所以，除非你真的，真的，必须近似，否则最好不要。

小开

检查如果这是有效的或不就我的测试用例，我能够得到这个工作。

假设number是k;

按降序排序百分比。
从降序遍历每个百分比。
计算k的百分比第一个百分比采取数学。输出的天花板。
下一个k = k-1
遍历直到所有百分比被消耗。

小开

我已经实现了Varun Vohra的答案在这里的列表和字典的方法。

import math
import numbers
import operator
import itertools




def round_list_percentages(number_list):
"""
Takes a list where all values are numbers that add up to 100,
and rounds them off to integers while still retaining a sum of 100.


A total value sum that rounds to 100.00 with two decimals is acceptable.
This ensures that all input where the values are calculated with [fraction]/[total]
and the sum of all fractions equal the total, should pass.
"""
# Check input
if not all(isinstance(i, numbers.Number) for i in number_list):
raise ValueError('All values of the list must be a number')


# Generate a key for each value
key_generator = itertools.count()
value_dict = {next(key_generator): value for value in number_list}
return round_dictionary_percentages(value_dict).values()




def round_dictionary_percentages(dictionary):
"""
Takes a dictionary where all values are numbers that add up to 100,
and rounds them off to integers while still retaining a sum of 100.


A total value sum that rounds to 100.00 with two decimals is acceptable.
This ensures that all input where the values are calculated with [fraction]/[total]
and the sum of all fractions equal the total, should pass.
"""
# Check input
# Only allow numbers
if not all(isinstance(i, numbers.Number) for i in dictionary.values()):
raise ValueError('All values of the dictionary must be a number')
# Make sure the sum is close enough to 100
# Round value_sum to 2 decimals to avoid floating point representation errors
value_sum = round(sum(dictionary.values()), 2)
if not value_sum == 100:
raise ValueError('The sum of the values must be 100')


# Initial floored results
# Does not add up to 100, so we need to add something
result = {key: int(math.floor(value)) for key, value in dictionary.items()}


# Remainders for each key
result_remainders = {key: value % 1 for key, value in dictionary.items()}
# Keys sorted by remainder (biggest first)
sorted_keys = [key for key, value in sorted(result_remainders.items(), key=operator.itemgetter(1), reverse=True)]


# Otherwise add missing values up to 100
# One cycle is enough, since flooring removes a max value of < 1 per item,
# i.e. this loop should always break before going through the whole list
for key in sorted_keys:
if sum(result.values()) == 100:
break
result[key] += 1


# Return
return result

小开

下面是@varun-vohra答案的一个简单的Python实现:

def apportion_pcts(pcts, total):
proportions = [total * (pct / 100) for pct in pcts]
apportions = [math.floor(p) for p in proportions]
remainder = total - sum(apportions)
remainders = [(i, p - math.floor(p)) for (i, p) in enumerate(proportions)]
remainders.sort(key=operator.itemgetter(1), reverse=True)
for (i, _) in itertools.cycle(remainders):
if remainder == 0:
break
else:
apportions[i] += 1
remainder -= 1
return apportions

你需要math， itertools， operator。

小开

对于那些在pandas系列中有百分比的人，这里是我的最大余数法(如在Varun Vohra的回答是中)的实现，在这里你甚至可以选择你想要四舍五入的小数。

import numpy as np


def largestRemainderMethod(pd_series, decimals=1):


floor_series = ((10**decimals * pd_series).astype(np.int)).apply(np.floor)
diff = 100 * (10**decimals) - floor_series.sum().astype(np.int)
series_decimals = pd_series - floor_series / (10**decimals)
series_sorted_by_decimals = series_decimals.sort_values(ascending=False)


for i in range(0, len(series_sorted_by_decimals)):
if i < diff:
series_sorted_by_decimals.iloc[[i]] = 1
else:
series_sorted_by_decimals.iloc[[i]] = 0


out_series = ((floor_series + series_sorted_by_decimals) / (10**decimals)).sort_values(ascending=False)


return out_series

小开

这是一个Ruby gem，实现了最大余数方法: https://github.com/jethroo/lare_round < / p >

使用方法:

a =  Array.new(3){ BigDecimal('0.3334') }
# => [#<BigDecimal:887b6c8,'0.3334E0',9(18)>, #<BigDecimal:887b600,'0.3334E0',9(18)>, #<BigDecimal:887b4c0,'0.3334E0',9(18)>]
a = LareRound.round(a,2)
# => [#<BigDecimal:8867330,'0.34E0',9(36)>, #<BigDecimal:8867290,'0.33E0',9(36)>, #<BigDecimal:88671f0,'0.33E0',9(36)>]
a.reduce(:+).to_f
# => 1.0

小开

注意:所选的答案是改变数组的顺序，这是不可取的，在这里我提供了更多不同的变化，以实现相同的结果，并保持数组的顺序

讨论

给定[98.88, .56, .56]，你想如何舍入它?你有四种选择

1-四舍五入，并从其余数字中减去加法，因此结果为[98, 1, 1]

这可能是一个很好的答案，但如果我们有[97.5, .5, .5, .5, .5, .5]呢?那么你需要四舍五入到[95, 1, 1, 1, 1, 1]

你明白是怎么回事了吗?如果你添加更多类似0的数字，你将从剩下的数字中失去更多的值。当你有一个像[40, .5, .5 , ... , .5]这样的类零数字的大数组时，这可能会非常麻烦。当你四舍五入时，你可以得到一个1数组:[1, 1, .... , 1]

所以集合不是一个好选择。

2-四舍五入。所以[98.88, .56, .56]变成[98, 0, 0]，那么你比100小2。你忽略任何已经为0的数，然后把它们的差加起来，得到最大的数。所以越大的数字就会得到越多。

3-和前面一样，向下四舍五入，但你根据小数降序排序，根据小数划分差异，所以最大的小数将得到差异。

4-四舍五入，但你把你加到下一个数字上的数加起来。就像一个波一样，你添加的东西会被重定向到数组的末尾。所以[98.88, .56, .56]变成了[99, 0, 1]

这些都不是理想的，所以要注意您的数据会失去形状。

在这里，我为情况2和3提供了一个代码(因为当你有很多类似零的数字时，情况1是不实际的)。它是现代的Js，不需要任何库来使用

2例

const v1 = [13.626332, 47.989636, 9.596008, 28.788024];// => [ 14, 48, 9, 29 ]
const v2 = [16.666, 16.666, 16.666, 16.666, 16.666, 16.666] // => [ 17, 17, 17, 17, 16, 16 ] 
const v3 = [33.333, 33.333, 33.333] // => [ 34, 33, 33 ]
const v4 = [33.3, 33.3, 33.3, 0.1] // => [ 34, 33, 33, 0 ]
const v5 = [98.88, .56, .56] // =>[ 100, 0, 0 ]
const v6 = [97.5, .5, .5, .5, .5, .5] // => [ 100, 0, 0, 0, 0, 0 ]


const normalizePercentageByNumber = (input) => {
const rounded: number[] = input.map(x => Math.floor(x));
const afterRoundSum = rounded.reduce((pre, curr) => pre + curr, 0);
const countMutableItems = rounded.filter(x => x >=1).length;
const errorRate = 100 - afterRoundSum;
    

const deductPortion = Math.ceil(errorRate / countMutableItems);
    

const biggest = [...rounded].sort((a, b) => b - a).slice(0, Math.min(Math.abs(errorRate), countMutableItems));
const result = rounded.map(x => {
const indexOfX = biggest.indexOf(x);
if (indexOfX >= 0) {
x += deductPortion;
console.log(biggest)
biggest.splice(indexOfX, 1);
return x;
}
return x;
});
return result;
}

3例

const normalizePercentageByDecimal = (input: number[]) => {


const rounded= input.map((x, i) => ({number: Math.floor(x), decimal: x%1, index: i }));


const decimalSorted= [...rounded].sort((a,b)=> b.decimal-a.decimal);
    

const sum = rounded.reduce((pre, curr)=> pre + curr.number, 0) ;
const error= 100-sum;
    

for (let i = 0; i < error; i++) {
const element = decimalSorted[i];
element.number++;
}


const result= [...decimalSorted].sort((a,b)=> a.index-b.index);
    

return result.map(x=> x.number);
}

4例

你只需要计算在每次汇总的数字中增加或减去多少额外的空气，然后在下一项中再增加或减去它。

const v1 = [13.626332, 47.989636, 9.596008, 28.788024];// => [14, 48, 10, 28 ]
const v2 = [16.666, 16.666, 16.666, 16.666, 16.666, 16.666] // => [17, 16, 17, 16, 17, 17]
const v3 = [33.333, 33.333, 33.333] // => [33, 34, 33]
const v4 = [33.3, 33.3, 33.3, 0.1] // => [33, 34, 33, 0]


const normalizePercentageByWave= v4.reduce((pre, curr, i, arr) => {


let number = Math.round(curr + pre.decimal);
let total = pre.total + number;


const decimal = curr - number;


if (i == arr.length - 1 && total < 100) {
const diff = 100 - total;
total += diff;
number += diff;
}


return { total, numbers: [...pre.numbers, number], decimal };


}, { total: 0, numbers: [], decimal: 0 });

小开

如果你只有两个选择你很好地使用Math.round()。唯一有问题的值对是X.5(例如;37.5和62.5)它会四舍五入两个值，你将得到101%，你可以在这里尝试:

https://jsfiddle.net/f8np1t0k/2/

因为你需要始终显示100%，你只需从它们中删除一个百分比，例如在第一个

const correctedARounded = Number.isInteger(aRounded-0.5) ? a - 1 : a

或者你可以选择有更多%选票的选项。

1% diff的错误在1-100对值的划分的10k例中发生114次。

小开

我的JS实现Varun Vohra的回答很受欢迎

const set1 = [13.626332, 47.989636, 9.596008, 28.788024];
// const set2 = [24.25, 23.25, 27.25, 25.25];


const values = set1;


console.log('Total: ', values.reduce((accum, each) => accum + each));
console.log('Incorrectly Rounded: ',
values.reduce((accum, each) => accum + Math.round(each), 0));


const adjustValues = (values) => {
// 1. Separate integer and decimal part
// 2. Store both in a new array of objects sorted by decimal part descending
// 3. Add in original position to "put back" at the end
const flooredAndSortedByDecimal = values.map((value, position) => (
{
floored: Math.floor(value),
decimal: value - Number.parseInt(value),
position
}
)).sort(({decimal}, {decimal: otherDecimal}) => otherDecimal - decimal);


const roundedTotal = values.reduce((total, value) => total + Math.floor(value), 0);
let availableForDistribution = 100 - roundedTotal;


// Add 1 to each value from what's available
const adjustedValues = flooredAndSortedByDecimal.map(value => {
const { floored, ...rest } = value;
let finalPercentage = floored;
if(availableForDistribution > 0){
finalPercentage = floored + 1;
availableForDistribution--;
}


return {
finalPercentage,
...rest
}
});


// Put back and return the new values
return adjustedValues
.sort(({position}, {position: otherPosition}) => position - otherPosition)
.map(({finalPercentage}) => finalPercentage);
}


const finalPercentages = adjustValues(values);
console.log({finalPercentages})


// { finalPercentage: [14, 48, 9, 29]}

小开

或者像这样简单，你只需要累积误差…

const p = [13.626332, 47.989636, 9.596008, 28.788024];
const round = (a, e = 0) => a.map(x => (r = Math.round(x + e), e += x - r, r));
console.log(round(p));

结果:[14,48,9,29]

小开

我用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;
}

如何使四舍五入百分比加起来为100%

讨论

2例

3例

4例