<< problem 341 - Golomb's self-describing sequence |
![]() |
Matrix Sum - problem 345 >> |
Problem 343: Fractional Sequences
(see projecteuler.net/problem=343)
For any positive integer k, a finite sequence a_i of fractions dfrac{x_i}{y_i} is defined by:
a_1 = dfrac{1}{k} and
a_i = dfrac{x_{i-1}+1}{y_{i-1} - 1} reduced to lowest terms for i>1.
When a_i reaches some integer n, the sequence stops. (That is, when y_i=1.)
Define f(k) = n.
For example, for k = 20:
1/20 → 2/19 → 3/18 → 1/6 → 2/5 → 3/4 → 4/3 → 5/2 → 6/1 = 6
So f(20) = 6.
Also f(1) = 1, f(2) = 2, f(3) = 1 and sum{f(k^3)} = 118937 for 1 <= k <= 100.
Find sum{f(k^3)} for 1 <= k <= 2 * 10^6.
Very inefficient solution
My code needs more than 60 seconds to find the correct result. (scroll down to the benchmark section)
Apparantly a much smarter algorithm exists - or my implementation is just inefficient.
My Algorithm
The bruteForce()
function was written in a few minutes - and as expected is too slow for 2 * 10^6 but nevertheless proved to be a good help while debugging my faster algorithm:
- start with
numerator = 1
anddenominator = k
, then repeat untildenominator == 1
: - add 1 to the
numerator
and subtract 1 from thedenominator
- call
gcd
to check whether they share a factor, if yes, divide both by that factor
- the sum
numerator + denominator
remains constant ifgcd == 1
- the
gcd
is always 1 ifnumerator + denominator
is a prime number - if
gcd > 1
thengcd == numerator
numerator
will slowly increase from 1 to the smallest prime factor of numerator + denominator
, then reset to 1,then slowly increase to the next prime factor, etc.
Since the initial value of
numerator + denominator
is 1 + k, we are basically factorizing 1 + k.In the very last cycle,
numerator + denominator
will be the largest prime factor of 1 + k.Since the algorithm stops if
denominator == 1
I know that the last numerator
is the largest prime factor of 1 + k, minus 1.My function
getMaxFactor()
returns the largest prime factor of its argument.Therefore
getMaxFactor(k + 1) - 1
is equivalent to f(k).One problem remains: factorization of large numbers is hard.
Unfortunately, the problem statement asks for k^3 where k can be 2 * 10^6 such that I have to factorize 8 * 10^18 + 1
(by the way: the largest prime factor of that number is 666667).
Wolfram Alpha told me that x^3 + 1 can be simplified:
x^3 + 1 = (x + 1) (x^2 - x + 1)
So instead of factorizing a single huge number x^3 + 1 I can factorize two much smaller numbers.
The largest prime factor found in x + 1 or x^2 - x + 1 is the largest prime factor of x^3 + 1.
I tried several tricks to further speed up the factorization:
- my standard prime sieve finds all primes below 2 * 10^6 → the largest factor of a prime is the prime itself
- trial division using these primes
- divide the current number by each factor to reduce it as fast as possible
- if the reduced number becomes 1, then I'm finished
- if the square of the current prime is larger than the reduced number, then the reduced number must be a prime
Desperately I search the web for factorization methods that are fast AND easy to implement.
Fermat's factorization method was a nice candidate - but I can't measure any speedup (see en.wikipedia.org/wiki/Fermat's_factorization_method).
Maybe the
getFermatFactors()
turns out to be more useful in another Project Euler problem ... I keep it here for the sake of completeness.My experiments with Pollard's rho algorithm were a desaster: the program became much slower (maybe I had a bug somewhere, see en.wikipedia.org/wiki/Pollard's_rho_algorithm).
Each computation of
getMaxFactor
is independent of each other. That's a perfect use case for multi-core CPUs !If you uncomment
//#define PARALLEL
then most modern C++ compilers (G++, Visual C++, Intel C++, etc.) will distribute the workload to all available CPUs.In my case I achieved an almost perfect performance boost: the solution is found 5.1 times faster on my 8-core computer (in about 28 seconds).
I consider this speedup to be "almost linear" because my computer isn't a true 8-core system, it has 4 cores plus hyperthreading.
Interactive test
You can submit your own input to my program and it will be instantly processed at my server:
This is equivalent toecho 200 | ./343
Output:
Note: the original problem's input 10000
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. Or just jump to my GitHub repository.
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
// ---------- a few routines from my toolbox ----------
// greatest common divisor
template <typename T>
T gcd(T a, T b)
{
while (a != 0)
{
T c = a;
a = b % a;
b = c;
}
return b;
}
// odd prime numbers are marked as "true" in a bitvector
std::vector<bool> sieve;
unsigned int primeLimit = 0;
// return true, if x is a prime number
bool isSmallPrime(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) + 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;
}
}
}
// return (a*b) % modulo
unsigned long long mulmod(unsigned long long a, unsigned long long b, unsigned long long modulo)
{
// (a * b) % modulo = (a % modulo) * (b % modulo) % modulo
a %= modulo;
b %= modulo;
// fast path
if (a <= 0xFFFFFFF && b <= 0xFFFFFFF)
return (a * b) % modulo;
// we might encounter overflows (slow path)
// the number of loops depends on b, therefore try to minimize b
if (b > a)
std::swap(a, b);
// bitwise multiplication
unsigned long long result = 0;
while (a > 0 && b > 0)
{
// b is odd ? a*b = a + a*(b-1)
if (b & 1)
{
result += a;
result %= modulo;
// skip b-- because the bit-shift at the end will remove the lowest bit anyway
}
// b is even ? a*b = (2*a)*(b/2)
a <<= 1;
a %= modulo;
// next bit
b >>= 1;
}
return result;
}
// return (base^exponent) % modulo
unsigned long long powmod(unsigned long long base, unsigned long long exponent, unsigned long long modulo)
{
unsigned long long result = 1;
while (exponent > 0)
{
// fast exponentation:
// odd exponent ? a^b = a*a^(b-1)
if (exponent & 1)
result = mulmod(result, base, modulo);
// even exponent ? a^b = (a*a)^(b/2)
base = mulmod(base, base, modulo);
exponent >>= 1;
}
return result;
}
// Miller-Rabin-test
bool isPrime(unsigned long long p)
{
// modified for problem 343: invoke isSmallPrime where appropriate
if (p < primeLimit)
return isSmallPrime(p);
// IMPORTANT: requires mulmod(a, b, modulo) and powmod(base, exponent, modulo)
// some code from https://ronzii.wordpress.com/2012/03/04/miller-rabin-primality-test/
// with optimizations from http://ceur-ws.org/Vol-1326/020-Forisek.pdf
// good bases can be found at http://miller-rabin.appspot.com/
// trivial cases
const unsigned int bitmaskPrimes2to31 = (1 << 2) | (1 << 3) | (1 << 5) | (1 << 7) |
(1 << 11) | (1 << 13) | (1 << 17) | (1 << 19) |
(1 << 23) | (1 << 29); // = 0x208A28Ac
if (p < 31)
return (bitmaskPrimes2to31 & (1 << p)) != 0;
if (p % 2 == 0 || p % 3 == 0 || p % 5 == 0 || p % 7 == 0 || // divisible by a small prime
p % 11 == 0 || p % 13 == 0 || p % 17 == 0)
return false;
if (p < 17*19) // we filtered all composite numbers < 17*19, all others below 17*19 must be prime
return true;
// test p against those numbers ("witnesses")
// good bases can be found at http://miller-rabin.appspot.com/
const unsigned int STOP = 0;
const unsigned int TestAgainst1[] = { 377687, STOP };
const unsigned int TestAgainst2[] = { 31, 73, STOP };
const unsigned int TestAgainst3[] = { 2, 7, 61, STOP };
// first three sequences are good up to 2^32
const unsigned int TestAgainst4[] = { 2, 13, 23, 1662803, STOP };
const unsigned int TestAgainst7[] = { 2, 325, 9375, 28178, 450775, 9780504, 1795265022, STOP };
// good up to 2^64
const unsigned int* testAgainst = TestAgainst7;
// use less tests if feasible
if (p < 5329)
testAgainst = TestAgainst1;
else if (p < 9080191)
testAgainst = TestAgainst2;
else if (p < 4759123141ULL)
testAgainst = TestAgainst3;
else if (p < 1122004669633ULL)
testAgainst = TestAgainst4;
// find p - 1 = d * 2^j
auto d = p - 1;
d >>= 1;
unsigned int shift = 0;
while ((d & 1) == 0)
{
shift++;
d >>= 1;
}
// test p against all bases
do
{
auto x = powmod(*testAgainst++, d, p);
// is test^d % p == 1 or -1 ?
if (x == 1 || x == p - 1)
continue;
// now either prime or a strong pseudo-prime
// check test^(d*2^r) for 0 <= r < shift
bool maybePrime = false;
for (unsigned int r = 0; r < shift; r++)
{
// x = x^2 % p
// (initial x was test^d)
x = mulmod(x, x, p);
// x % p == 1 => not prime
if (x == 1)
return false;
// x % p == -1 => prime or an even stronger pseudo-prime
if (x == p - 1)
{
// next iteration
maybePrime = true;
break;
}
}
// not prime
if (!maybePrime)
return false;
} while (*testAgainst != STOP);
// prime
return true;
}
// ---------- problem-specific code ----------
// brute-force: just follow the chain and reduce fractions as soon as possible
unsigned long long bruteForce(unsigned long long k)
{
auto numerator = 1ULL;
auto denominator = k;
// until the fraction is a natural number ...
while (denominator != 1)
{
// figure out whether the fraction can be reduced
auto sharedFactor = gcd(numerator, denominator);
if (sharedFactor == 1)
{
// already a proper fraction, increase numerator and decrease denominator
numerator++;
denominator--;
}
else
{
// reduce to a proper fraction
numerator /= sharedFactor;
denominator /= sharedFactor;
}
}
return numerator;
}
// Fermat's factorization method
std::pair<unsigned long long, unsigned long long> getFermatFactors(unsigned long long n, unsigned int maxIterations)
{
// https://en.wikipedia.org/wiki/Fermat%27s_factorization_method
// trivial case: even numbers
if (n % 2 == 0)
return std::make_pair(2, n / 2);
// already a perfect square ?
auto x = (unsigned long long)sqrt(n);
if (x * x == n)
return std::make_pair(x, x);
while (maxIterations-- > 0)
{
x++;
auto y2 = x*x - n;
// optimization: all perfect squares mod 16 are always 0,1,4,9
// based on https://www.johndcook.com/blog/2008/11/17/fast-way-to-test-whether-a-number-is-a-square/
auto mod16 = y2 % 16;
if (mod16 == 0 || mod16 == 1 || mod16 == 4 || mod16 == 9)
{
// is y2 a perfect square ?
auto y = (unsigned long long)sqrt(y2);
if (y*y == y2)
// yes, found factorization
return std::make_pair(x - y, x + y);
}
}
// aborted, no factors found
return std::make_pair(1ULL, n);
}
std::vector<unsigned int> smallPrimes;
// return the largest prime factor, if x is prime then return x
unsigned long long getMaxFactor(unsigned long long x, unsigned long long minResult = 0)
{
// no use in factorizing a prime :-)
if (isPrime(x))
return x;
unsigned long long result = 1;
auto reduce = x;
for (auto factor : smallPrimes)
{
// at most one prime factor left ?
if (factor * factor > reduce)
break;
// remove current prime factor
bool foundFactor = false;
while (reduce % factor == 0)
{
result = std::max<unsigned long long>(result, factor);
reduce /= factor;
// abort search, prime factors will be too small
if (reduce < minResult)
return result;
foundFactor = true;
}
if (foundFactor)
{
// only a prime left ?
if (isPrime(reduce))
break;
// try Fermat's factorization
#define FERMAT
#ifdef FERMAT
// limit number of iterations
auto fermat = getFermatFactors(reduce, 10);
// found a factorization ?
if (fermat.first > 1)
return std::max(getMaxFactor(fermat.first), getMaxFactor(fermat.second));
#endif
}
}
// x can be a prime, too
return std::max(reduce, result);
}
int main()
{
unsigned int limit = 2000000;
std::cin >> limit;
// generate enough primes
primeLimit = limit + 100; // a few extra primes
fillSieve(primeLimit);
// copy to a dense array
smallPrimes = { 2 };
for (unsigned int i = 3; i <= primeLimit; i += 2)
if (isPrime(i))
smallPrimes.push_back(i);
unsigned long long sum = 0;
#define PARALLEL
#ifdef PARALLEL
#pragma omp parallel for reduction(+:sum) schedule(dynamic)
#endif
for (long long i = 1; i <= limit; i++) // note: Visual C++ needs a signed data type
{
//auto slow = bruteForce(i * i * i);
//#define FACTORIZE_LARGE
#ifdef FACTORIZE_LARGE
// takes about 3x as long as the #else version
auto factor = getMaxFactor(i * i * i + 1) - 1;
#else
// i^3+1 = (i+1)(i^2-i+1)
// getMaxFactor(i^3+1) = max(getMaxFactor(i+1), getMaxFactor(i^2-i+1))
unsigned long long a = i + 1;
unsigned long long b = i*i - i + 1;
auto factor2 = getMaxFactor(b);
// abort search early if no big factor possible
auto factor1 = 1ULL;
if (factor2 < a)
factor1 = getMaxFactor(a, factor2);
// choose the bigger factor
auto factor = std::max(factor1, factor2);
#endif
// remember: fast algorithm is getMaxFactor(k + 1) - 1 => I still have to subtract 1
sum += factor - 1;
}
std::cout << sum << std::endl;
return 0;
}
This solution contains 59 empty lines, 86 comments and 14 preprocessor commands.
Benchmark
The correct solution to the original Project Euler problem was found in 147 seconds (exceeding the limit of 60 seconds).
The code can be accelerated with OpenMP but the timings refer to the single-threaded version on an Intel® Core™ i7-2600K CPU @ 3.40GHz.
Peak memory usage was about 3 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
September 29, 2017 submitted solution
September 29, 2017 added comments
Difficulty
Project Euler ranks this problem at 35% (out of 100%).
Links
projecteuler.net/thread=343 - the best forum on the subject (note: you have to submit the correct solution first)
Code in various languages:
Python github.com/Meng-Gen/ProjectEuler/blob/master/343.py (written by Meng-Gen Tsai)
Java github.com/thrap/project-euler/blob/master/src/Java/Problem343.java (written by Magnus Solheim Thrap)
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 | 688 | 689 | 690 | 691 | 692 | 693 | 694 | 695 | 696 | 697 | 698 | 699 | 700 |
701 | 702 | 703 | 704 | 705 | 706 | 707 | 708 | 709 | 710 | 711 | 712 | 713 | 714 | 715 | 716 | 717 | 718 | 719 | 720 | 721 | 722 | 723 | 724 | 725 |
726 | 727 | 728 | 729 | 730 | 731 | 732 | 733 | 734 | 735 | 736 | 737 | 738 | 739 | 740 | 741 | 742 | 743 | 744 | 745 | 746 | 747 | 748 | 749 | 750 |
751 | 752 | 753 | 754 | 755 | 756 | 757 | 758 | 759 | 760 | 761 | 762 | 763 | 764 | 765 | 766 | 767 | 768 | 769 | 770 | 771 | 772 | 773 | 774 | 775 |
776 | 777 | 778 | 779 | 780 | 781 | 782 | 783 | 784 | 785 | 786 | 787 | 788 | 789 | 790 | 791 | 792 | 793 | 794 | 795 | 796 | 797 | 798 | 799 | 800 |
801 | 802 | 803 | 804 | 805 | 806 | 807 | 808 | 809 | 810 | 811 | 812 | 813 | 814 | 815 | 816 | 817 | 818 | 819 | 820 | 821 | 822 | 823 |
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 341 - Golomb's self-describing sequence |
![]() |
Matrix Sum - problem 345 >> |