<< problem 230 - Fibonacci Words | The Race - problem 232 >> |
Problem 231: The prime factorisation of binomial coefficients
(see projecteuler.net/problem=231)
The binomial coefficient ^10 C_3 = 120.
120 = 23 * 3 * 5 = 2 * 2 * 2 * 3 * 5, and 2 + 2 + 2 + 3 + 5 = 14.
So the sum of the terms in the prime factorisation of ^10 C_3 is 14.
Find the sum of the terms in the prime factorisation of ^20000000 C_15000000.
My Algorithm
Aside from a standard prime sieve, the main work is done in add(n)
:
The binomial coefficient is: ^n{C_k} = {{n}choose{k}} = dfrac{n!}{(n-k)! k!}
where the factorial is n! = 1 * 2 * 3 * 4 * ... * n, e.g. 10! = 1 * 2 * 3 * 4 * ... * 10.
However, the problem statement doesn't ask for the factorial but the sum of prime factors of all elements in the factorial sequence.
That means add(10!) = 1 + 2 + 3 + (2 + 2) + 5 + (2 + 3) + 7 + (2 + 2 + 2) + (3 + 3) + (2 + 5) = 45.
The main insight here is that add(a * b) = add(a) + add(b).
You can see that every second number contains prime factor 2, every third prime factor 3, every fifth prime factor 5 ... and so on.
There are \lfloor frac{10}{2} \rfloor = 5 elements which contain prime factor 2 at least once. That's a sum of 2 * 5 = 10.
There are \lfloor frac{10}{2^2} \rfloor = 2 elements which contain prime factor 2 at least twice. That's a sum of 2 * 2 = 4 on top.
There are \lfloor frac{10}{2^3} \rfloor = 1 elements which contain prime factor 2 at least three times. That's a sum of 2 * 1 = 2 on top.
The sum of all prime factors 2 is 10 + 4 + 2 = 16.
Following the same logic, but this time prime factor 3:
There are \lfloor frac{10}{3} \rfloor = 3 elements which contain prime factor 3 at least once. That's a sum of 3 * 3 = 9.
There are \lfloor frac{10}{3^2} \rfloor = 1 elements which contain prime factor 3 at least twice. That's a sum of 3 * 1 = 3.
The sum of all prime factors 3 is 9 + 3 = 12.
Now the algorithm becomes apparent:
- iterate over all potential prime factors
p
- compute how many numbers contain
p
, addp * count
to the sum - compute how many numbers contain
p^2
, addp * count
to the sum - compute how many numbers contain
p^3
, addp * count
to the sum - ...
Alternative Approaches
My first approach was to generate a huge look-up table:
- if a number
i
is a prime number, setsum[i] = i
- then for each number
i
, multiply it by all primesp
and setsum[i * p] = sum[i] + p
- add all
sums[]
up toi
, that's simplysums[i] += sums[i - 1]
because alli
are processed in increasing order
I felt very uncomfortable of that memory consumption for such a "small" problem. And it was about 10x slower.
So I spent a whole commuter ride thinking about the problem and came up with the current solution ...
Note: read access to that precomputed table is extremely fast ! If you need to query heaps of factorial prime sums then
my first approach might be an actually viable solution.
Interactive test
You can submit your own input to my program and it will be instantly processed at my server:
This is equivalent toecho "10 3" | ./231
Output:
Note: the original problem's input 20000000 15000000
cannot be entered
because just copying results is a soft skill reserved for idiots.
(this interactive test is still under development, computations will be aborted after one second)
My code
… was written in C++11 and can be compiled with G++, Clang++, Visual C++. You can download it, too.
#include <iostream>
#include <vector>
#include <vector>
// odd prime numbers are marked as "true" in a bitvector
std::vector<bool> sieve;
// collection of all primes from the sieve (I do this because it's faster)
std::vector<unsigned int> primes = { 2 };
// return true, if x is a prime number
bool isPrime(unsigned int x)
{
// handle even numbers
if ((x & 1) == 0)
return x == 2;
// lookup for odd numbers
return sieve[x >> 1];
}
// find all prime numbers from 2 to size
void fillSieve(unsigned int size)
{
// store only odd numbers
const unsigned int half = size >> 1;
// allocate memory
sieve.resize(half, true);
// 1 is not a prime number
sieve[0] = false;
// process all relevant prime factors
for (unsigned int i = 1; 2*i*i < half; i++)
// do we have a prime factor ?
if (sieve[i])
{
// mark all its multiples as false
unsigned int current = 3*i+1;
while (current < half)
{
sieve[current] = false;
current += 2*i+1;
}
}
}
// ----- here the main algorithm starts -----
// return sum of all prime factors of n!
unsigned long long add(unsigned int n)
{
unsigned long long sum = 0;
for (auto p : primes)
{
// prime too large ? => done
if (p > n)
return sum;
// start with p^1, then p^2 in next iteration
unsigned long long multipleP = p;
// initial count
unsigned long long count = n / multipleP;
do
{
// adjust result
sum += p * count;
// increase exponent by one, that means p^i => p^(i+1)
multipleP *= p;
// update count for next iteration
count = n / multipleP;
} while (count > 0); // multipleP > n
}
return sum;
}
// ----- below is my first approach -----
// my first attempt: compute a huge lookup table where
// (code not used anymore)
std::vector<unsigned long long> sums;
void generateTable(unsigned int limit)
{
sums.resize(limit + 1, 0);
for (unsigned int i = 2; i < sums.size(); i++)
{
// prime number ? its only prime factor is the number itself
if (sums[i] == 0)
sums[i] = i;
// multiply with all prime numbers
for (auto p : primes)
{
// too large ?
if (i * p >= sums.size())
break;
// add current prime factor
sums[i * p] = sums[i] + p;
}
// add all prime factors of (i-1)! to i
// => that's the sum of prime factors of i!
sums[i] += sums[i - 1];
}
}
int main()
{
// read input values n >= k
unsigned int n = 20000000;
unsigned int k = 15000000;
std::cin >> n >> k;
// generate all prime numbers
fillSieve(n);
// extract prime numbers
for (unsigned int i = 3; i <= n; i += 2)
if (isPrime(i))
primes.push_back(i);
std::cout << add(n) - (add(n - k) + add(k)) << std::endl;
// older, slower algorithm
//generateTable(n);
//std::cout << sums[n] - (sums[n - k] + sums[k]) << std::endl;
return 0;
}
This solution contains 22 empty lines, 35 comments and 3 preprocessor commands.
Benchmark
The correct solution to the original Project Euler problem was found in 0.14 seconds on an Intel® Core™ i7-2600K CPU @ 3.40GHz.
Peak memory usage was about 13 MByte.
(compiled for x86_64 / Linux, GCC flags: -O3 -march=native -fno-exceptions -fno-rtti -std=gnu++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
June 28, 2017 submitted solution
June 28, 2017 added comments
Difficulty
Project Euler ranks this problem at 40% (out of 100%).
Links
projecteuler.net/thread=231 - the best forum on the subject (note: you have to submit the correct solution first)
Code in various languages:
Python github.com/hughdbrown/Project-Euler/blob/master/euler-231.py (written by Hugh Brown)
Python github.com/nayuki/Project-Euler-solutions/blob/master/python/p231.py (written by Nayuki)
C++ github.com/Meng-Gen/ProjectEuler/blob/master/231.cc (written by Meng-Gen Tsai)
C++ github.com/roosephu/project-euler/blob/master/231.cpp (written by Yuping Luo)
C++ github.com/smacke/project-euler/blob/master/cpp/231.cpp (written by Stephen Macke)
C++ github.com/zmwangx/Project-Euler/blob/master/231/231.cpp (written by Zhiming Wang)
C github.com/LaurentMazare/ProjectEuler/blob/master/e231.c (written by Laurent Mazare)
Java github.com/dcrousso/ProjectEuler/blob/master/PE231.java (written by Devin Rousso)
Java github.com/nayuki/Project-Euler-solutions/blob/master/java/p231.java (written by Nayuki)
Java github.com/thrap/project-euler/blob/master/src/Java/Problem231.java (written by Magnus Solheim Thrap)
Go github.com/frrad/project-euler/blob/master/golang/Problem231.go (written by Frederick Robinson)
Mathematica github.com/nayuki/Project-Euler-solutions/blob/master/mathematica/p231.mathematica (written by Nayuki)
Mathematica github.com/steve98654/ProjectEuler/blob/master/231.nb
Clojure github.com/rm-hull/project-euler/blob/master/src/euler231.clj (written by Richard Hull)
Perl github.com/shlomif/project-euler/blob/master/project-euler/231/euler-231-v1.pl (written by Shlomi Fish)
Those links are just an unordered selection of source code I found with a semi-automatic search script on Google/Bing/GitHub/whatever.
You will probably stumble upon better solutions when searching on your own.
Maybe not all linked resources produce the correct result and/or exceed time/memory limits.
Heatmap
Please click on a problem's number to open my solution to that problem:
green | solutions solve the original Project Euler problem and have a perfect score of 100% at Hackerrank, too | |
yellow | solutions score less than 100% at Hackerrank (but still solve the original problem easily) | |
gray | problems are already solved but I haven't published my solution yet | |
blue | solutions are relevant for Project Euler only: there wasn't a Hackerrank version of it (at the time I solved it) or it differed too much | |
orange | problems are solved but exceed the time limit of one minute or the memory limit of 256 MByte | |
red | problems are not solved yet but I wrote a simulation to approximate the result or verified at least the given example - usually I sketched a few ideas, too | |
black | problems are solved but access to the solution is blocked for a few days until the next problem is published | |
[new] | the flashing problem is the one I solved most recently |
I stopped working on Project Euler problems around the time they released 617.
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 |
251 | 252 | 253 | 254 | 255 | 256 | 257 | 258 | 259 | 260 | 261 | 262 | 263 | 264 | 265 | 266 | 267 | 268 | 269 | 270 | 271 | 272 | 273 | 274 | 275 |
276 | 277 | 278 | 279 | 280 | 281 | 282 | 283 | 284 | 285 | 286 | 287 | 288 | 289 | 290 | 291 | 292 | 293 | 294 | 295 | 296 | 297 | 298 | 299 | 300 |
301 | 302 | 303 | 304 | 305 | 306 | 307 | 308 | 309 | 310 | 311 | 312 | 313 | 314 | 315 | 316 | 317 | 318 | 319 | 320 | 321 | 322 | 323 | 324 | 325 |
326 | 327 | 328 | 329 | 330 | 331 | 332 | 333 | 334 | 335 | 336 | 337 | 338 | 339 | 340 | 341 | 342 | 343 | 344 | 345 | 346 | 347 | 348 | 349 | 350 |
351 | 352 | 353 | 354 | 355 | 356 | 357 | 358 | 359 | 360 | 361 | 362 | 363 | 364 | 365 | 366 | 367 | 368 | 369 | 370 | 371 | 372 | 373 | 374 | 375 |
376 | 377 | 378 | 379 | 380 | 381 | 382 | 383 | 384 | 385 | 386 | 387 | 388 | 389 | 390 | 391 | 392 | 393 | 394 | 395 | 396 | 397 | 398 | 399 | 400 |
401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 419 | 420 | 421 | 422 | 423 | 424 | 425 |
426 | 427 | 428 | 429 | 430 | 431 | 432 | 433 | 434 | 435 | 436 | 437 | 438 | 439 | 440 | 441 | 442 | 443 | 444 | 445 | 446 | 447 | 448 | 449 | 450 |
451 | 452 | 453 | 454 | 455 | 456 | 457 | 458 | 459 | 460 | 461 | 462 | 463 | 464 | 465 | 466 | 467 | 468 | 469 | 470 | 471 | 472 | 473 | 474 | 475 |
476 | 477 | 478 | 479 | 480 | 481 | 482 | 483 | 484 | 485 | 486 | 487 | 488 | 489 | 490 | 491 | 492 | 493 | 494 | 495 | 496 | 497 | 498 | 499 | 500 |
501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 509 | 510 | 511 | 512 | 513 | 514 | 515 | 516 | 517 | 518 | 519 | 520 | 521 | 522 | 523 | 524 | 525 |
526 | 527 | 528 | 529 | 530 | 531 | 532 | 533 | 534 | 535 | 536 | 537 | 538 | 539 | 540 | 541 | 542 | 543 | 544 | 545 | 546 | 547 | 548 | 549 | 550 |
551 | 552 | 553 | 554 | 555 | 556 | 557 | 558 | 559 | 560 | 561 | 562 | 563 | 564 | 565 | 566 | 567 | 568 | 569 | 570 | 571 | 572 | 573 | 574 | 575 |
576 | 577 | 578 | 579 | 580 | 581 | 582 | 583 | 584 | 585 | 586 | 587 | 588 | 589 | 590 | 591 | 592 | 593 | 594 | 595 | 596 | 597 | 598 | 599 | 600 |
601 | 602 | 603 | 604 | 605 | 606 | 607 | 608 | 609 | 610 | 611 | 612 | 613 | 614 | 615 | 616 | 617 | 618 | 619 | 620 | 621 | 622 | 623 | 624 | 625 |
626 | 627 | 628 | 629 | 630 | 631 | 632 | 633 | 634 | 635 | 636 | 637 | 638 | 639 | 640 | 641 | 642 | 643 | 644 | 645 | 646 | 647 | 648 | 649 | 650 |
651 | 652 | 653 | 654 | 655 | 656 | 657 | 658 | 659 | 660 | 661 | 662 | 663 | 664 | 665 | 666 | 667 | 668 | 669 | 670 | 671 | 672 | 673 | 674 | 675 |
676 | 677 | 678 | 679 | 680 | 681 | 682 | 683 | 684 | 685 | 686 | 687 |
I scored 13526 points (out of 15700 possible points, top rank was 17 out of ≈60000 in August 2017) at Hackerrank's Project Euler+.
My username at Project Euler is stephanbrumme while it's stbrumme at Hackerrank.
Look at my progress and performance pages to get more details.
Copyright
I hope you enjoy my code and learn something - or give me feedback how I can improve my solutions.
All of my solutions can be used for any purpose and I am in no way liable for any damages caused.
You can even remove my name and claim it's yours. But then you shall burn in hell.
The problems and most of the problems' images were created by Project Euler.
Thanks for all their endless effort !!!
<< problem 230 - Fibonacci Words | The Race - problem 232 >> |