Getting 100% with rounded percentages

I’m currently working with reports and graphs and I had the following request for one of these reports:

Let’s use percentages when we are displaying the scores. The percentage should be relative to the total score.

OK, that seems easy enough so let’s calculate those percentages:

18.562874251497007%
20.958083832335326%
18.562874251497007%
19.161676646706585%
22.75449101796407%

Oh and let’s round those percentages to show whole numbers.

Fine, a simple rounding will do:

19%
21%
19%
19%
23%

But wait… that doesn’t add up to 100%! It actually adds up to 101%! Well that’s the problem with blind rounding. So, how can we guarantee that the percentage results will always add up to 100%?

I did some research and, since I didn’t want to spend too much time on tricky algorithms and math headaches, I was looking for a simple solution. One thing to note is that reliance on the original decimal data is not critical so we can can take some liberties with our rounding algorithm. I came across this Stack Overflow question:

How to make rounded percentages add up to 100%

which pointed me to the Largest Remainder Method algorithm. This is a very simple algorithm that consists of:

1. Rounding all values down to the nearest integer value;
2. Determining the difference between the sum of the rounded values and total value;
3. Distributing the difference between the rounded values in decreasing order of their decimal parts.

Considering the initial dataset:

Let’s start by rounding down all values:

=> [18, 20, 18, 19, 22]

Now the difference between the sum of the rounded values and total value (in this case 100%):

=> 3

This means that we have to distribute 3% across our rounded percentages. The algorithm says that this distribution should be done in decreasing order of the values’ decimal part, so let’s first sort them by their decimal part:

=> [20.958083832335326, 22.75449101796407, 18.562874251497007, 18.562874251497007, 19.161676646706585]

And finally distribute the remaining 3%:

The result is:

=> [21, 23, 19, 18, 19]

which adds up to 100(%)!

This is a relatively easy and fast way to ensure that rounded percentages add up to 100%. Again, this is not the best rounding algorithm considering that we pretty much disregard the decimal part but I would say that for most cases this is good enough. Finally I’ll leave here a more condensed version of the algorithm:

Do you know any other algorithms or have your own ideas to approach this problem? If so, I’d love to hear them. Let me know if you found this article useful.

I am currently working at Runtime Revolution. We are a team of developers that work from sunny Lisbon to everywhere. We focus on delivering and maintaining the best possible products to our clients, while having fun, learning and helping each other.