Problem 13: Large sum

(see projecteuler.net/problem=13)

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

37107287533902102798797998220837590246510135740250
46376937677490009712648124896970078050417018260538
74324986199524741059474233309513058123726617309629
91942213363574161572522430563301811072406154908250
23067588207539346171171980310421047513778063246676
89261670696623633820136378418383684178734361726757
28112879812849979408065481931592621691275889832738
44274228917432520321923589422876796487670272189318
47451445736001306439091167216856844588711603153276
70386486105843025439939619828917593665686757934951
62176457141856560629502157223196586755079324193331
64906352462741904929101432445813822663347944758178
92575867718337217661963751590579239728245598838407
58203565325359399008402633568948830189458628227828
80181199384826282014278194139940567587151170094390
35398664372827112653829987240784473053190104293586
86515506006295864861532075273371959191420517255829
71693888707715466499115593487603532921714970056938
54370070576826684624621495650076471787294438377604
53282654108756828443191190634694037855217779295145
36123272525000296071075082563815656710885258350721
45876576172410976447339110607218265236877223636045
17423706905851860660448207621209813287860733969412
81142660418086830619328460811191061556940512689692
51934325451728388641918047049293215058642563049483
62467221648435076201727918039944693004732956340691
15732444386908125794514089057706229429197107928209
55037687525678773091862540744969844508330393682126
18336384825330154686196124348767681297534375946515
80386287592878490201521685554828717201219257766954
78182833757993103614740356856449095527097864797581
16726320100436897842553539920931837441497806860984
48403098129077791799088218795327364475675590848030
87086987551392711854517078544161852424320693150332
59959406895756536782107074926966537676326235447210
69793950679652694742597709739166693763042633987085
41052684708299085211399427365734116182760315001271
65378607361501080857009149939512557028198746004375
35829035317434717326932123578154982629742552737307
94953759765105305946966067683156574377167401875275
88902802571733229619176668713819931811048770190271
25267680276078003013678680992525463401061632866526
36270218540497705585629946580636237993140746255962
24074486908231174977792365466257246923322810917141
91430288197103288597806669760892938638285025333403
34413065578016127815921815005561868836468420090470
23053081172816430487623791969842487255036638784583
11487696932154902810424020138335124462181441773470
63783299490636259666498587618221225225512486764533
67720186971698544312419572409913959008952310058822
95548255300263520781532296796249481641953868218774
76085327132285723110424803456124867697064507995236
37774242535411291684276865538926205024910326572967
23701913275725675285653248258265463092207058596522
29798860272258331913126375147341994889534765745501
18495701454879288984856827726077713721403798879715
38298203783031473527721580348144513491373226651381
34829543829199918180278916522431027392251122869539
40957953066405232632538044100059654939159879593635
29746152185502371307642255121183693803580388584903
41698116222072977186158236678424689157993532961922
62467957194401269043877107275048102390895523597457
23189706772547915061505504953922979530901129967519
86188088225875314529584099251203829009407770775672
11306739708304724483816533873502340845647058077308
82959174767140363198008187129011875491310547126581
97623331044818386269515456334926366572897563400500
42846280183517070527831839425882145521227251250327
55121603546981200581762165212827652751691296897789
32238195734329339946437501907836945765883352399886
75506164965184775180738168837861091527357929701337
62177842752192623401942399639168044983993173312731
32924185707147349566916674687634660915035914677504
99518671430235219628894890102423325116913619626622
73267460800591547471830798392868535206946944540724
76841822524674417161514036427982273348055556214818
97142617910342598647204516893989422179826088076852
87783646182799346313767754307809363333018982642090
10848802521674670883215120185883543223812876952786
71329612474782464538636993009049310363619763878039
62184073572399794223406235393808339651327408011116
66627891981488087797941876876144230030984490851411
60661826293682836764744779239180335110989069790714
85786944089552990653640447425576083659976645795096
66024396409905389607120198219976047599490197230297
64913982680032973156037120041377903785566085089252
16730939319872750275468906903707539413042652315011
94809377245048795150954100921645863754710598436791
78639167021187492431995700641917969777599028300699
15368713711936614952811305876380278410754449733078
40789923115535562561142322423255033685442488917353
44889911501440648020369068063960672322193204149535
41503128880339536053299340368006977710650566631954
81234880673210146739058568557934581403627822703280
82616570773948327592232845941706525094512325230608
22918802058777319719839450180888072429661980811197
77158542502016545090413245809786882778948721859617
72107838435069186155435662884062257473692284509516
20849603980134001723930671666823555245252804609722
53503534226472524250874054075591789781264330331690

Algorithm

All numbers are read as std::string from stdin and their digits stored in an std::vector
where the least significant digits ("the right-most") are stored at the beginning of the container.

In plain English: 12345 is stored as { 5,4,3,2,1 }

Another std::vector is initially zero and then each number is added to it using the basic addition
algorithm learned in primary school:
- add each digit sum[i] += x[i] beginning with the least significant ("the right-most" where i=0)
- if sum[i] >= 10 then we have to "carry" that highest digit, which is 1, over to the next position:
sum[i+1]++ and sum[i] -= 10

The input numbers always consist of 50 digits but the sum may have a few more due to the "carry" feature.
I decided to add 10 spare digits for a total of 50+10=60 (see MinDigits).

When printing the most-significant digits, some of those "spare" digits may be still unused, that means they are zero.
I have to skip those and print the first 10 "valid" digits.

Alternative Approaches

Language with BigInteger support (such as Java or Python) can probably solve this problem in one line of code.

My code

… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, as well as the input data, too.

The code contains #ifdefs to switch between the original problem and the Hackerrank version.
Enable #ifdef ORIGINAL to produce the result for the original problem (default setting for most problems).

#include <string>
#include <vector>
#include <iostream>
 
int main()
{
// store each digit separately
// input has 50 digits
// highest digits might overflow and require a few extra digits
// (I believe +2 would suffice, too)
const unsigned int MinDigits = 50 + 10;
// all digits are initially zero, least significant has index 0
std::vector<unsigned int> sum(MinDigits, 0);
// the resulting number will be sum[0] + 10*sum[1] + 100*sum[2] + ...
 
unsigned int numbers = 100;
 
//#define ORIGINAL
#ifndef ORIGINAL
std::cin >> numbers;
#endif
 
while (numbers--)
{
// read a single number as a string
std::string strAdd;
std::cin >> strAdd;
 
// convert to digits
std::vector<unsigned int> add;
// process string in reverse: least significant digits first
for (auto i = strAdd.rbegin(); i != strAdd.rend(); i++)
add.push_back(*i - '0'); // convert from ASCII
// fill high/unused positions with zeros
add.resize(sum.size(), 0);
 
// add all digits
for (unsigned int i = 0; i < add.size(); i++)
{
sum[i] += add[i];
 
// overflow ? => sum[i] is 10 .. 18
if (sum[i] >= 10)
{
sum[i + 1]++; // sum[i + 1] = sum[i] % 10
sum[i] -= 10; // sum[i] %= 10
}
}
}
 
// skip high zeros
auto i = sum.rbegin();
while (*i == 0)
i++;
 
// print first ten digits
unsigned int numDigits = 10;
while (numDigits-- > 0)
std::cout << *i++;
 
return 0;
}

This solution contains 10 empty lines, 15 comments and 5 preprocessor commands.

Interactive test

You can submit your own input to my program and it will be instantly processed at my server:

This live test is based on the Hackerrank problem.

Number of test cases (1-100):

Input data (separated by spaces or newlines):

This is equivalent to
echo "5 37107287533902102798797998220837590246510135740250 46376937677490009712648124896970078050417018260538 \
74324986199524741059474233309513058123726617309629 91942213363574161572522430563301811072406154908250 \
23067588207539346171171980310421047513778063246676
" | ./13

Output:

(please click 'Go !')

(this interactive test is still under development, computations will be aborted after one second)

Benchmark

The correct solution to the original Project Euler problem was found in less than 0.01 seconds on a Intel® Core™ i7-2600K CPU @ 3.40GHz.
(compiled for x86_64 / Linux, GCC flags: -O3 -march=native -fno-exceptions -fno-rtti -std=c++11 -DORIGINAL)

See here for a comparison of all solutions.

Note: interactive tests run on a weaker (=slower) computer. Some interactive tests are compiled without -DORIGINAL.

Changelog

February 23, 2017 submitted solution
March 30, 2017 added comments

Hackerrank

see https://www.hackerrank.com/contests/projecteuler/challenges/euler013

My code solves 3 out of 3 test cases (score: 100%)

Difficulty

Project Euler ranks this problem at 5% (out of 100%).

Hackerrank describes this problem as easy.

Note:
Hackerrank has strict execution time limits (typically 2 seconds for C++ code) and often a much wider input range than the original problem.
In my opinion, Hackerrank's modified problems are usually a lot harder to solve. As a rule thumb: brute-force is never an option.

Links

projecteuler.net/thread=13 - the best forum on the subject (note: you have to submit the correct solution first)

Code in various languages:

Python: www.mathblog.dk/project-euler-13/ (written by Kristian Edlund)
Haskell: github.com/nayuki/Project-Euler-solutions/blob/master/haskell/p013.hs (written by Nayuki)
Java: github.com/nayuki/Project-Euler-solutions/blob/master/java/p013.java (written by Nayuki)
Mathematica: github.com/nayuki/Project-Euler-solutions/blob/master/mathematica/p013.mathematica (written by Nayuki)
C: github.com/eagletmt/project-euler-c/blob/master/10-19/problem13.c (written by eagletmt)
Go: github.com/frrad/project-euler/blob/master/golang/Problem013.go (written by Frederick Robinson)
Javascript: github.com/dsernst/ProjectEuler/blob/master/13 Large sum.js (written by David Ernst)
Scala: github.com/samskivert/euler-scala/blob/master/Euler013.scala (written by Michael Bayne)

Heatmap

green problems solve the original Project Euler problem and have a perfect score of 100% at Hackerrank, too.
yellow problems score less than 100% at Hackerrank (but still solve the original problem).
gray problems are already solved but I haven't published my solution yet.
blue problems are solved and there wasn't a Hackerrank version of it at the time I solved it or I didn't care about it because it differed too much.

Please click on a problem's number to open my solution to that problem:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50
51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75
76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100
101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200
201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225
226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250
The 163 solved problems had an average difficulty of 22.2% at Project Euler and I scored 11,907 points (out of 13200) at Hackerrank's Project Euler+.
My username at Project Euler is stephanbrumme while it's stbrumme at Hackerrank.
more about me can be found on my homepage, especially in my coding blog.
some names mentioned on this site may be trademarks of their respective owners.
thanks to the KaTeX team for their great typesetting library !