Work out the first ten digits of the sum of the following one-hundred 50-digit numbers.

Of course I didn't include the numbers in the description...

I am sure there is a better way to do this. I just did a simple solution, where I add all the numbers and take the first 10 digits.

import java.math.BigInteger;

public class ProjectEuler13 {

    public static void main(String[] args) {
        String[] numbers = { "37107287533902102798797998220837590246510135740250",
                "53503534226472524250874054075591789781264330331690" };
        long time = System.nanoTime();
        String result = sum(numbers).toString().substring(0, 10);
        time = System.nanoTime() - time;
        System.out.println("Result: " + result + "\nTime in nanoseconds: " + time);

    public static BigInteger sum(String[] values) {
        if (values.length == 0) {
            return BigInteger.ZERO;
        BigInteger result = new BigInteger(values[0]);
        for (int i = 1; i < values.length; i++) {
            result = result.add(new BigInteger(values[i]));
        return result;


Note that the values above are Strings, because it was easier to type that than:

BigInteger[] values = {new BigInteger("...")}; // and so on


Result: 5537376230
Time in nanoseconds: 57357242


  1. It's really just performance. There's gotta be a better way to do this, but I can't think of a single way.

3 Answers 3



See the comments for corner cases.


When I solved this problem, I readily noticed what the problem expected the programmers to understand. Let me put it this way...

An analogy

Have you ever seen a car's odometer? If you have, you will notice that the digits in the far right increase fastest while you drive. The next digit, i.e. towards the left updates less frequently (ten times slower). The next is even slower and the left-most digit is the slowest; it doesn't update even if you drive for hours at a stretch.


What is its relation to the problem at hand? We must understand the significance of the least significant digits is to provide the "carry" to be added to the next significant digit. Let's take our analogy and proceed with it. The rightmost digits act as the miles, tens-of-miles, hundreds-of-miles counters, that update frequently. When they cross \$9\$ and return to \$0\$, they increment the immediate left digit. It is essentially updating using the carry. These carries too become lesser and lesser in frequency as we move leftwards.

For example, take \$10,950\$ and \$15,456\$. Add them up and you get \$26,406\$. We want the first two digits of their sum. If we take \$10,000\$ and \$15,000\$, we get a slightly different answer: \$25,000\$.

If we analyse the first 2 (i.e. leftmost) digits of the answers, we see that they \$25\$ and \$26\$ differ in their one's place. Their first digits match up. That's why I said "slightly".

In order to improve the precision, take an extra (buffer) digit. Using three digits: \$109+154=263\$. There you go! We now have the answers matching in their first two digits. This theory can be generalized to obtain the first \$n\$ digits of the sum of a collection of numbers (of length more than \$n\$ digits). The number of buffer digits depends on the "number of numbers" A rough relation would be

$$ No.\ of\ buffer\ digits = log(no.\ of\ items) $$

Trial and error supports this. I urge you to prove it yourself.

The code

Finally, let's get cracking

public class ProjectEuler13 {

    public static void main(String[] args) {
        String[] numbers = {
            // The big long list
        long time = System.nanoTime();
        String result = sum(numbers, 10).substring(0, 10);
        time = System.nanoTime() - time;
        System.out.println("Result: " + result + "\nTime in nanoseconds: " + time);

    public static String sum(String[] values, int numberOfDigits) {
        // best to take an overestimate
        int buffer = (int) Math.ceil(Math.log10(values.length)); // = 2 for 50
        int length = numberOfDigits + buffer;
        long result = 0;
        for (String value : values) {
            result += Long.parseLong(value.substring(0, length));
        return String.valueOf(result);


Even on my slow computer:

Result: 5537376230
Time in nanoseconds: 2493350

  • \$\begingroup\$ Can you explain why it is so slow? (Though faster than OP version). When implementing similar solution in Python (which should be comparative in terms of speed) I get a loop time of 81.2 µs, i.e. 81.200 ns... \$\endgroup\$
    – holroy
    Nov 12, 2015 at 15:21
  • 4
    \$\begingroup\$ This is fallacious - it appears to work only because natural counterexamples are rare under the given conditions. Just take '99999' and '00001' - you cannot get any final prefix digit until you have added all digits. With rounding you can get an approximation of a prefix (i.e. something that is numerically close) but if you want an exact prefix then you need to do something like what Deduplicator suggested. IOW, you can only bail out when it is proved that using more digits cannot change the computed prefix anymore, which will never happen in the case of my little counterexample. \$\endgroup\$
    – DarthGizka
    Apr 26, 2016 at 13:06
  • \$\begingroup\$ P.S.: the ratio of naturally occurring counterexamples in random inputs with the Euler #13 parameters is about 1 in 200. \$\endgroup\$
    – DarthGizka
    Apr 26, 2016 at 14:55
  • 1
    \$\begingroup\$ In any case, I know the feeling. I've been burnt by clever ideas of mine often enough that always futz the resulting code with copious doses of random inputs (overnight if need be) if I cannot go the route of a full mathematical workup. And even if I do the workup, I still do the futzing because I know how fallible I am... ;-) \$\endgroup\$
    – DarthGizka
    Apr 27, 2016 at 6:57
  • 1
    \$\begingroup\$ Lest readers get the wrong impression: ambigram_maker's scheme is valid and certainly worthy of close study because it can avoid a lot of unnecessary work in the majority of cases. The only problem is that it is not complete: it needs a bit of extra work for detecting rare carries that can bubble up from deep below. IOW, it needs a bit of logic that tells when processing can stop because further digits cannot change the answer (as indicated by Deduplicator). \$\endgroup\$
    – DarthGizka
    Apr 27, 2016 at 7:21

Yes, there is a (potentially) better way:

Take advantage of the fact that you start with input in the decimal system.

  1. Allocate an array which can assuredly store all digits of the result.
  2. Add the n-th digits (starting at the front) and add the subtotal into the result.
  3. Repeat step 2 until even the maximal subtotal cannot influence the first ten digits of the result any longer.
  4. Profit.

As an aside, I don't think the task was intended to be solved with a bignum library at all, but that works too.


Here is a refinement of ambigram_maker's solution for dealing with potential carries bubbling up from the far end, which essentially boils down to merging it with Deduplicator's idea.

The crux of the matter is detecting and/or handling situations that are equivalent to the odometer showing all nines, so that the next tick must cause all digits to change.

But let's take things step by step. If we are summing n values by processing them column by column then the carry from one column to the next can be n - 1 in the worst case. Hence the accumulator variables used must be able to store values that are up to n - 1 bigger than the maximum value of a column cell, in order to avoid overflow.

This means that the number of k-ary digits required for a column accumulator is the width of one column plus ceil(log(n - 1 + 1) / log(k)) extra digits. In the decimal realm that's:

R = ceil(log10(n)) = (int)log10(n - 1) + 1  // n >= 2

A long can hold up to floor(63 * log10(2)) == 18 decimal digits, which means that we can make a source column up to 18 - R digits wide without risking overflow.

Also, if adding the worst-case carry of n - 1 to the lowest R digits of a column sum does not cause a carry then nothing that happens in the as-yet unprocessed columns could possibly affect any higher digits of the result. In other words, the effect of the unknown carry out of the unprocessed part must be confined to the R lowest digits of the current result.

In code the test for a sufficient level of overflow isolation looks like this:

long m = (long)pow(10, R);

if (sum % m < m - (n - 1))
    // a carry <= (n - 1) from below cannot cause carry out of the low R digits

There is an additional consideration, though: if R is computed as shown earlier then the overflow reserve can become very small, even zero. The latter will happen if the number of input values is a power of 10, so that a carry of up to n - 1 = 10^R - 1 can only be accomodated if sum % 10^R == 0, i.e. once every 10^R random inputs. Hence it is advisable to increase R by 1 or 2, in order to reduce the frequency of extended computations by a factor of 10 or 100 (roughly speaking).

This logic also allows it to give an alternative explanation for ambigram_maker's solution. If D result digits are desired and we compute a column sum of the first D + R digits then the effect of the remaining, unprocessed digits must be confined to the low R digits of the result if above condition holds; in that case all but the lowest R digits of the result must be correct. If at least one of the input numbers has a non-zero first digit then the sum cannot be shorter than the inputs, and taking the first D gives the desired result. For this computation the accumulator needs to be big enough to hold R + D + R digits (one R for accrued carries, and one R for absorbing carries from below).

The apparent discrepancy between the actual performance of ambigram_maker's solution with R == 2 (only one problem every 200 random inputs) vs. the pessimistic outlook of the test criterion (for R == 2 and N == 100, only every 100th input does not require extended computation) comes from the fact that the test must necessarily assume the worst about the unknown, unprocessed portions of the input. Hence the suggestion to increase R appropriately.

Finally, here's the code. I don't have a Java environment handy, so I had to write it in a hashish language (my LINQPad is always at most one key tap away):

const int FULL_DIGITS_PER_LONG = 18;

static string sum_prefix (string[] values, int result_digits = 10)
    Trace.Assert(values.Length > 0);

    int n = values.Length;
    int r = (int)Math.Ceiling(Math.Log10(n)) + 2;   // # of overflow reserve digits
    int u = FULL_DIGITS_PER_LONG - r;           // # of remaining/usable digits per long
    int m = (int)Math.Pow(10, r);               // modulus for the overflow reserve digits

    Trace.Assert(u >= result_digits + r);   // result not guaranteed to fit in a single limb otherwise
    Trace.Assert(m >= n);                   // ward off oopses

    int l = values[0].Length;

    Trace.Assert(l >= result_digits + r);
    Trace.Assert(values.Where((si) => si.Length != l).Count() == 0);
    Trace.Assert(values.Where((sj) => sj[0] != '0').Count() > 0);

    var sum_limbs = new List<long>();
    int digits = result_digits + r;         // in the first round, use exactly what's needed
    long sum;                               // final values of sum and digits needed after the loop

    for (int offset = 0; ; offset += digits, digits = u)
        digits = Math.Min(digits, l - offset);  // # of source digits in this round

        sum = 0;
        foreach (string s in values)
            sum += long.Parse(s.Substring(offset, digits));

        if (sum % m < m - (n - 1) || offset >= l - digits) // worst-case carry can be absorbed


    for (int i = sum_limbs.Count; --i >= 0; digits = u)
        long carry = sum / (long)Math.Pow(10, digits);
        sum = sum_limbs[i] + carry;

    return sum.ToString().Substring(0, result_digits);

UPDATE: with optimisations like this, people will naturally ask what the bottom lines is. Hence I pitted the above function against the following code based on the builtin BigInteger type, after surreptitiously tweaking the carry reserve from R+1 to R+2:

static string via_BigInteger (string[] values, int digits = 10)
    var sum = new System.Numerics.BigInteger(0);

    foreach (var s in values)
        sum += System.Numerics.BigInteger.Parse(s);

    return sum.ToString().Substring(0, digits);

Result: 0.943 ms for the BigInteger code, 0.018 ms for the smart prefix calculation (per call, averaged, random inputs). That's a speedup factor of 50 - well worth the effort.

The number of extended computation rounds corresponded well to the value expected for the Euler task parameters and R+2, which is around 1%. For R+1 the value was an expected 10%, and the timing was 0.019 ms.


Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.