entityMap|blocks|key|59ip8|text|也许做到这一点的“最好”方法(引用“最佳”是一个主观术语)是保持你所在位置的连续(非整数)计数，并进行四舍五入。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2jv3r|那个|c7n7l|价值。|3tvfq|然后将其与历史一起使用，以确定应该使用什么值。例如，使用您给出的值：|a08e3|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|code-block|syntax|javascript|b5bol|在每个阶段，您不会对数字本身进行舍入。取而代之的是，您可以对|fc8bu|累积|ca97r|值并计算出从前一个基线达到该值的最佳整数-该基线是前一行的累积值(四舍五入)。|ckh6d|这行得通，因为你是|f0en|注释|4r6ng|在每个阶段都会丢失信息，而是更智能地使用信息。“正确的”四舍五入的值在最后一列，您可以看到它们的总和为100。|120iq|在上面的第三个值中，您可以看到这与盲目舍入每个值之间的区别。而|cqp54|通常会四舍五入为|ab2ct|，累积的|r8gb|正确地向下舍入为|3fi0m|-这意味着只有|16spp|需要添加到以前的基线|aqu96|..。|enjdd|这也适用于“有问题的”序列，如三个粗略的-|2el4h|值，其中|84rrj|一个|1tn38|其中有几个应该四舍五入：|9ksik|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^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|1N|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|1O|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|1P|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|1Q|9|@]|A|@]|B|$]]|$2|I|4|J|6|K|8|1R|9|@]|A|@]|B|$L|M]]|$2|N|4|O|6|7|8|1S|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|1T|9|@]|A|@]|B|$]]|$2|R|4|S|6|7|8|1U|9|@]|A|@]|B|$]]|$2|T|4|U|6|7|8|1V|9|@]|A|@]|B|$]]|$2|V|4|W|6|7|8|1W|9|@]|A|@]|B|$]]|$2|X|4|Y|6|7|8|1X|9|@]|A|@]|B|$]]|$2|Z|4|10|6|7|8|1Y|9|@]|A|@]|B|$]]|$2|11|4|12|6|7|8|1Z|9|@]|A|@]|B|$]]|$2|13|4|14|6|7|8|20|9|@]|A|@]|B|$]]|$2|15|4|16|6|7|8|21|9|@]|A|@]|B|$]]|$2|17|4|18|6|7|8|22|9|@]|A|@]|B|$]]|$2|19|4|1A|6|7|8|23|9|@]|A|@]|B|$]]|$2|1B|4|1C|6|7|8|24|9|@]|A|@]|B|$]]|$2|1D|4|1E|6|7|8|25|9|@]|A|@]|B|$]]|$2|1F|4|1G|6|7|8|26|9|@]|A|@]|B|$]]|$2|1H|4|1I|6|7|8|27|9|@]|A|@]|B|$]]|$2|1J|4|1K|6|7|8|28|9|@]|A|@]|B|$]]|$2|1L|4|1M|6|K|8|29|9|@]|A|@]|B|$L|M]]]]

Probably the "best" way to do this (quoted since "best" is a subjective term) is to keep a running (non-integral) tally of where you are, and round that value.

Then use that along with the history to work out what value should be used. For example, using the values you gave:

<pre><code>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
</code></pre>

At each stage, you don't round the number itself. Instead, you round the accumulated value and work out the best integer that reaches that value from the previous baseline - that baseline is the cumulative value (rounded) of the previous row.

This works because you're not losing information at each stage but rather using the information more intelligently. The 'correct' rounded values are in the final column and you can see that they sum to 100.

You can see the difference between this and blindly rounding each value, in the third value above. While <code>9.596008</code> would normally round up to <code>10</code>, the accumulated <code>71.211976</code> correctly rounds down to <code>71</code> - this means that only <code>9</code> is needed to add to the previous baseline of <code>62</code>.

<hr>

This also works for "problematic" sequence like three roughly-<code>1/3</code> values, where one of them should be rounded up:

<pre><code>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
</code></pre>

entityMap|blocks|key|27g4b|text|您可以尝试跟踪由于四舍五入而产生的误差，如果累积误差大于当前数字的小数部分，则对颗粒进行四舍五入。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|962q4|13.62+->+14+(%2B.38)
47.98+->+48+(%2B.02+(%2B.40+total))
+9.59+->+10+(%2B.41+(%2B.81+total))
28.78+->+28+(round+down+because+.81+>+.78)
------------
++++++++100|code-block|syntax|javascript|6ocmf|我不确定这是否会在总体上起作用，但如果颠倒顺序，它似乎也会起到类似的作用：|fsohe|28.78+->+29+(%2B.22)
+9.59+->++9+(-.37;+rounded+down+because+.59+>+.22)
47.98+->+48+(-.35)
13.62+->+14+(%2B.03)
------------
++++++++100|4uhai|我相信在一些边缘情况下，这可能会失效，但任何方法都至少会有一定的随意性，因为您基本上是在修改输入数据。^0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|N|9|@]|A|@]|B|$]]|$2|C|4|D|6|E|8|O|9|@]|A|@]|B|$F|G]]|$2|H|4|I|6|7|8|P|9|@]|A|@]|B|$]]|$2|J|4|K|6|E|8|Q|9|@]|A|@]|B|$F|G]]|$2|L|4|M|6|7|8|R|9|@]|A|@]|B|$]]]]

You could try keeping track of your error due to rounding, and then rounding against the grain if the accumulated error is greater than the fractional portion of the current number.

<pre><code>13.62 -&gt; 14 (+.38)
47.98 -&gt; 48 (+.02 (+.40 total))
 9.59 -&gt; 10 (+.41 (+.81 total))
28.78 -&gt; 28 (round down because .81 &gt; .78)
------------
 100
</code></pre>

Not sure if this would work in general, but it seems to work similar if the order is reversed:

<pre><code>28.78 -&gt; 29 (+.22)
 9.59 -&gt; 9 (-.37; rounded down because .59 &gt; .22)
47.98 -&gt; 48 (-.35)
13.62 -&gt; 14 (+.03)
------------
 100
</code></pre>

I'm sure there are edge cases where this might break down, but any approach is going to be at least somewhat arbitrary since you're basically modifying your input data.

entityMap|blocks|key|2di1m|text|不要对四舍五入的数字求和。你会得到不准确的结果。根据词条的数量和小数部分的分布，总数可能会显着下降。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|d9biq|显示|636jt|四舍五入的数字|eut8i|总和|63lm5|实际值。根据你表示数字的方式，实际的方法可能会有所不同。这样你就能得到|6f72|14+48+10+29|blu1r|_|ejlpp|45le1|100|a14u6|5gkni|无论你走哪条路，你都会有偏差。在您的示例中，如果不以错误的方式“舍入”一个值，就无法显示加起来为100的数字(最小误差应该是将9.596改为9)|gli5|编辑|cs9u9|您需要在以下选项之一中进行选择：|4cbi5|项目的准确性|dfpmc|求和的准确性(如果要对四舍五入的值求和)|9puld|四舍五入项与四舍五入和之间的一致性)|8s24g|大多数时候，处理百分比#3是最好的选择，因为当总和等于101%25时，比单个项目总和不等于100时更明显，并且您可以保持单个项目的准确性。在我看来，“四舍五入”9.596到9是不准确的。|a0mum|为了解释这一点，我有时会添加一个脚注，解释单个值是四舍五入的，可能不是100%25+-任何理解四舍五入的人都应该能够理解这种解释。^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|18|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|19|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|1A|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|1B|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|1C|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|1D|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|1E|9|@]|A|@]|B|$]]|$2|O|4|N|6|7|8|1F|9|@]|A|@]|B|$]]|$2|P|4|Q|6|7|8|1G|9|@]|A|@]|B|$]]|$2|R|4|-4|6|7|8|1H|9|@]|A|@]|B|$]]|$2|S|4|T|6|7|8|1I|9|@]|A|@]|B|$]]|$2|U|4|V|6|7|8|1J|9|@]|A|@]|B|$]]|$2|W|4|X|6|7|8|1K|9|@]|A|@]|B|$]]|$2|Y|4|Z|6|7|8|1L|9|@]|A|@]|B|$]]|$2|10|4|11|6|7|8|1M|9|@]|A|@]|B|$]]|$2|12|4|13|6|7|8|1N|9|@]|A|@]|B|$]]|$2|14|4|15|6|7|8|1O|9|@]|A|@]|B|$]]|$2|16|4|17|6|7|8|1P|9|@]|A|@]|B|$]]]]

DO NOT sum the rounded numbers. You're going to have inaccurate results. The total could be off significantly depending on the number of terms and the distribution of fractional parts. 

Display the rounded numbers but sum the actual values. Depending on how you're presenting the numbers, the actual way to do that would vary. That way you get

<blockquote>
<pre> 14
 48
 10
 29
 __
100</pre>
</blockquote>

Any way you go you're going to have discrepancy. There's no way in your example to show numbers that add up to 100 without "rounding" one value the wrong way (least error would be changing 9.596 to 9)

EDIT

You need to choose between one of the following:

<ol>
<li>Accuracy of the items</li>
<li>Accuracy of the sum (if you're summing rounded values)</li>
<li>Consistency between the rounded items and the rounded sum)</li>
</ol>

Most of the time when dealing with percentages #3 is the best option because it's more obvious when the total equals 101% than when the individual items don't total to 100, and you keep the individual items accurate. "Rounding" 9.596 to 9 is inaccurate in my opinion.

To explain this I sometimes add a footnote that explains that the individual values are rounded and may not total 100% - anyone that understands rounding should be able to understand that explanation.

entityMap|blocks|key|6iovh|text|有许多方法可以做到这一点，只要您不关心对原始小数数据的依赖。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|b8sdn|第一个也可能是最流行的方法是|8v1l4|最大余数法|3dqt0|这基本上是：|10n64|四舍五入|4r8v2|求和与100的差值|cmhoi|通过按项目小数部分的降序将1添加到项目来分配差值|f46aq|在你的例子中，它是这样的：|euarr|13.626332%25
47.989636%25
+9.596008%25
28.788024%25|code-block|syntax|javascript|f3rpl|如果你取整数部分，你会得到|f6d2b|13
47
+9
28|ap1rl|加起来是97，你还想再加3个。现在，您看一下小数部分，它们是|7tibg|.626332%25
.989636%25
.596008%25
.788024%25|ac64a|取最大的，直到总数达到100。所以你会得到：|3so0c|14
48
+9
29|bon3g|或者，您可以简单地选择显示一个小数位而不是整数值。因此，数字将是48.3和23.9，等等。这将使100的方差减少很多。^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|19|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|1A|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|1B|9|@]|A|@]|B|$]]|$2|G|4|H|6|7|8|1C|9|@]|A|@]|B|$]]|$2|I|4|J|6|7|8|1D|9|@]|A|@]|B|$]]|$2|K|4|L|6|7|8|1E|9|@]|A|@]|B|$]]|$2|M|4|N|6|7|8|1F|9|@]|A|@]|B|$]]|$2|O|4|P|6|7|8|1G|9|@]|A|@]|B|$]]|$2|Q|4|R|6|S|8|1H|9|@]|A|@]|B|$T|U]]|$2|V|4|W|6|7|8|1I|9|@]|A|@]|B|$]]|$2|X|4|Y|6|S|8|1J|9|@]|A|@]|B|$T|U]]|$2|Z|4|10|6|7|8|1K|9|@]|A|@]|B|$]]|$2|11|4|12|6|S|8|1L|9|@]|A|@]|B|$T|U]]|$2|13|4|14|6|7|8|1M|9|@]|A|@]|B|$]]|$2|15|4|16|6|S|8|1N|9|@]|A|@]|B|$T|U]]|$2|17|4|18|6|7|8|1O|9|@]|A|@]|B|$]]]]

There are many ways to do just this, provided you are not concerned about reliance on the original decimal data.

The first and perhaps most popular method would be the <a href="http://en.wikipedia.org/wiki/Largest_remainder_method" rel="noreferrer">Largest Remainder Method</a>

Which is basically:

<ol>
<li>Rounding everything down</li>
<li>Getting the difference in sum and 100</li>
<li>Distributing the difference by adding 1 to items in decreasing order of their decimal parts</li>
</ol>

In your case, it would go like this:

<pre><code>13.626332%
47.989636%
 9.596008%
28.788024%
</code></pre>

If you take the integer parts, you get

<pre><code>13
47
 9
28
</code></pre>

which adds up to 97, and you want to add three more. Now, you look at the decimal parts, which are

<pre><code>.626332%
.989636%
.596008%
.788024%
</code></pre>

and take the largest ones until the total reaches 100. So you would get:

<pre><code>14
48
 9
29
</code></pre>

Alternatively, you can simply choose to show one decimal place instead of integer values. So the numbers would be 48.3 and 23.9 etc. This would drop the variance from 100 by a lot.

entityMap|blocks|key|8ofoo|text|由于这里的答案似乎都不能很好地解决这个问题，下面是我的半模糊版本，使用|type|unstyled|depth|inlineStyleRanges|entityRanges|data|9nae2|得分点|bd87g|function+foo(l,+target)+{
++++var+off+=+target+-+_.reduce(l,+function(acc,+x)+{+return+acc+%2B+Math.round(x)+},+0);
++++return+_.chain(l).
++++++++++++sortBy(function(x)+{+return+Math.round(x)+-+x+}).
++++++++++++map(function(x,+i)+{+return+Math.round(x)+%2B+(off+>+i)+-+(i+>=+(l.length+%2B+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]|code-block|syntax|javascript^0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|J|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|K|9|@]|A|@]|B|$]]|$2|E|4|F|6|G|8|L|9|@]|A|@]|B|$H|I]]]]

Since none of the answers here seem to solve it properly, here's my semi-obfuscated version using <a href="http://underscorejs.org/" rel="noreferrer">underscorejs</a>:

<pre class="lang-js prettyprint-override"><code>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 &gt; i) - (i &gt;= (l.length + off)) }).
 value();
}

foo([13.626332, 47.989636, 9.596008, 28.788024], 100) // =&gt; [48, 29, 14, 9]
foo([16.666, 16.666, 16.666, 16.666, 16.666, 16.666], 100) // =&gt; [17, 17, 17, 17, 16, 16]
foo([33.333, 33.333, 33.333], 100) // =&gt; [34, 33, 33]
foo([33.3, 33.3, 33.3, 0.1], 100) // =&gt; [34, 33, 33, 0]
</code></pre>

entityMap|blocks|key|3hdmp|text|我写了一个C#版本的舍入助手，算法和|type|unstyled|depth|inlineStyleRanges|entityRanges|data|128in|Varun+Vohra的回答|bhrv0|，希望它能有所帮助。|epqap|public+static+List+GetPerfectRounding(List+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+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]+%2B=+deltaUnit);

++++return+rounded;
}|code-block|syntax|javascript|8fisg|它通过了以下单元测试：|5sdou|[TestMethod]
public+void+TestPerfectRounding()
{
++++CollectionAssert.AreEqual(Utils.GetPerfectRounding(
++++++++new+List+{3.333m,+3.334m,+3.333m},+10,+2),
++++++++new+List+{3.33m,+3.34m,+3.33m});

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

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


++++CollectionAssert.AreEqual(Utils.GetPerfectRounding(
++++++++new+List+{+13.626332m,+47.989636m,+9.596008m,+28.788024m+},+100,+0),
++++++++new+List+{14,+48,+9,+29});
++++CollectionAssert.AreEqual(Utils.GetPerfectRounding(
++++++++new+List+{+16.666m,+16.666m,+16.666m,+16.666m,+16.666m,+16.666m+},+100,+0),
++++++++new+List+{+17,+17,+17,+17,+16,+16+});
++++CollectionAssert.AreEqual(Utils.GetPerfectRounding(
++++++++new+List+{+33.333m,+33.333m,+33.333m+},+100,+0),
++++++++new+List+{+34,+33,+33+});
++++CollectionAssert.AreEqual(Utils.GetPerfectRounding(
++++++++new+List+{+33.3m,+33.3m,+33.3m,+0.1m+},+100,+0),
++++++++new+List+{+34,+33,+33,+0+});
}^0|0|0|0|0|0^^$0|$]|1|@$2|3|4|5|6|7|8|P|9|@]|A|@]|B|$]]|$2|C|4|D|6|7|8|Q|9|@]|A|@]|B|$]]|$2|E|4|F|6|7|8|R|9|@]|A|@]|B|$]]|$2|G|4|H|6|I|8|S|9|@]|A|@]|B|$J|K]]|$2|L|4|M|6|7|8|T|9|@]|A|@]|B|$]]|$2|N|4|O|6|I|8|U|9|@]|A|@]|B|$J|K]]]]

I wrote a C# version rounding helper, the algorithm is same as <a href="https://stackoverflow.com/a/13483710/1745885">Varun Vohra's answer</a>, hope it helps.



<pre class="lang-cs prettyprint-override"><code>public static List&lt;decimal&gt; GetPerfectRounding(List&lt;decimal&gt; original,
 decimal forceSum, int decimals)
{
 var rounded = original.Select(x =&gt; 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&lt;int&gt; applyDeltaSequence; 
 if (delta &lt; 0)
 {
 applyDeltaSequence = original
 .Zip(Enumerable.Range(0, int.MaxValue), (x, index) =&gt; new { x, index })
 .OrderBy(a =&gt; original[a.index] - rounded[a.index])
 .ThenByDescending(a =&gt; a.index)
 .Select(a =&gt; a.index).ToList();
 }
 else
 {
 applyDeltaSequence = original
 .Zip(Enumerable.Range(0, int.MaxValue), (x, index) =&gt; new { x, index })
 .OrderByDescending(a =&gt; original[a.index] - rounded[a.index])
 .Select(a =&gt; a.index).ToList();
 }

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

 return rounded;
}
</code></pre>

It pass the following Unit test:

<pre class="lang-cs prettyprint-override"><code>[TestMethod]
public void TestPerfectRounding()
{
 CollectionAssert.AreEqual(Utils.GetPerfectRounding(
 new List&lt;decimal&gt; {3.333m, 3.334m, 3.333m}, 10, 2),
 new List&lt;decimal&gt; {3.33m, 3.34m, 3.33m});

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

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


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

Consider the four percentages below, represented as <code>float</code> numbers:

<pre><code> 13.626332%
 47.989636%
 9.596008%
 28.788024%
 -----------
 100.000000%
</code></pre>

I need to represent these percentages as whole numbers. If I simply use <code>Math.round()</code>, I end up with a total of 101%. 

<pre><code>14 + 48 + 10 + 29 = 101
</code></pre>

If I use <code>parseInt()</code>, I end up with a total of 97%. 

<pre><code>13 + 47 + 9 + 28 = 97
</code></pre>

What's a good algorithm to represent any number of percentages as whole numbers while still maintaining a total of 100%?

<hr>

Edit: After reading some of the comments and answers, there are clearly many ways to go about solving this.

In my mind, to remain true to the numbers, the "right" result is the one that minimizes the overall error, defined by how much error rounding would introduce relative to the actual value:

<pre><code> 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)
</code></pre>

In case of a tie (3.33, 3.33, 3.33) an arbitrary decision can be made (e.g. 3, 4, 3).

How to make rounded percentages add up to 100%

单元测试

 考虑下面的四个百分比，表示为 数字： 13.626332%    47.989636%     9.596008%    28.788024%   -----------   100.000000% 我需要将这些百分比表示为整数。如果我简单地使用 ，我最终得到了101%的结果。 14 + 48 + 10 + 29 =...

问如何使四舍五入的百分比之和为100%
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使四舍五入的百分比之和为100%EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何使四舍五入的百分比之和为100%
EN