<< problem 336 - Maximix Arrangements | Fractional Sequences - problem 343 >> |
Problem 341: Golomb's self-describing sequence
(see projecteuler.net/problem=341)
The Golomb's self-describing sequence G(n) is the only nondecreasing sequence of natural numbers such that n appears exactly G(n) times in the sequence.
The values of G(n) for the first few n are
n123456789101112131415...
G(n)122334445556666...
You are given that G(10^3) = 86, G(10^6) = 6137.
You are also given that sum{G(n^3)} = 153506976 for 1 <= n < 10^3.
Find sum{G(n^3)} for 1 <= n < 10^6.
My Algorithm
I brute forced the first values up to 100 (far more can be found here: oeis.org/A001462/b001462.txt) and observed a certain pattern:
- G(1) = 1 and there is exactly one G(x) = 1
- G(2) = 2 and there are two x such that G(x) = 2 (it's 2 and 3)
- G(4) = 3 and there are two x such that G(x) = 3 (it's 4 and 5)
- G(6) = 4 and there are three x such that G(x) = 4 (it's 6, 7 and 8)
- G(9) = 5 and there are three x such that G(x) = 5 (it's 9, 10 and 11)
- G(12) = 6 and there are four x such that G(x) = 6 (it's 12, 13, 14 and 15)
- ...
1 * G(1) = 1 * 1 = 1 → all G(x > 1) appear at least twice
1 * G(1) + 2 * G(2) = 1 + 4 = 5 → all G(x > 5) appear at least three times
1 * G(1) + 2 * G(2) + 3 * G(3) = 1 + 4 + 6 = 11 → all G(x > 11) appear at least four times
I store these products in
products[]
(or compute them on-the-fly in the LOW_MEMORY
code path).It turns out that sum{x * G(x)} > {10^6}^3 for x approx 10 million.
Brute-forcing the first few million values of the Golomb sequence is no problem using the "recursive" Wikipedia formula:
a(1) = 1
a(n+1) = 1 + a (n + 1 - a( a(n) ) )
which can be simplified for a(n)
a(n) = 1 + a (n - a( a(n - 1) ) )
Once I know the upper limit of the number of elements I make use of a second observation:
I already demonstrated that G(1..3) is sufficient to know that any number 6 <= x <= 11 maps to a value to appears three times in the Golomb sequence.
But I still don't know which number ! (it can be 4 or 5)
The sums G(1) + G(2) = 3 and G(1) + G(2) + G(3) = 5 have a nice property:
I know there 6 values between those sums (it's 6 to 11). If I find the relative position
ratio
between the relevant products, then the sum at the same relative position contains the correct value.Let's compute G(x) for x = 10:
from = products[2] = 5
to = products[3] = 11
ratio = dfrac{10 - from}{to - from} = dfrac{10 - 5}{11 - 5} = dfrac{5}{6} approx 0.83333
low = sums[2] = G(1) + G(2) = 3
high = sums[3] = G(1) + G(2) + G(3) = 5
G(10) = low + roundUp((high - low) * ratio) = 3 + roundUp((5 - 3) * 0.83333) = 5
(that's good old en.wikipedia.org/wiki/Linear_interpolation)
My code became a mess when I replaced the temporary containers
sums
and produces
by variables.However, it cut the memory usage by 50%: from about 270 MByte (slightly above the inofficial limit of 256 MByte) down to 135 MByte.
#define LOW_MEMORY
is also about twice as fast.
Note
The Wikipedia page describes an O(1) formula which is unfortunately only asymptotic correct:
the result is more or less pretty close to the actual value but can't be used to solve this problem.
Nevertheless, the fast
function helped me a lot in my debugging session when some intermediate values were "strange".
Let's be honest: I discovered the connections between G(x) the sums and the products more or less by chance when I spent time on the commuter train home.
It was trial'n'error all the way - and therefore it's definitely not amongst my favorite problems.
Interactive test
You can submit your own input to my program and it will be instantly processed at my server:
This is equivalent toecho 1000 | ./341
Output:
Note: the original problem's input 1000000
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 <cmath>
// find the asymptotic value, quite often off by a few numbers (first four digits tend to be okay)
// note: unused code, but helped me a lot during debugging
double fast(unsigned long long n)
{
// golden ratio
const auto phi = (1 + sqrt(5.0)) / 2;
const auto constant = pow(phi, 2 - phi);
// see https://en.wikipedia.org/wiki/Golomb_sequence
return constant * pow(n, phi - 1);
}
int main()
{
unsigned int limit = 1000000;
std::cin >> limit;
// (10^6)^3 = 10^18
auto cubicLimit = (unsigned long long) limit * limit * limit;
// index 0 is not used, golomb(1) = 1
std::vector<unsigned long long> golomb = { 0, 1 };
#define LOW_MEMORY
#ifdef LOW_MEMORY
// precompute golomb[i] = G(i)
// stop when 1*G(1) + 2*G(2) + 3*G(3) + ... + i*G(i) >= 10^18
unsigned long long products = 1;
for (unsigned long long i = 2; products < cubicLimit; i++)
{
// https://en.wikipedia.org/wiki/Golomb_sequence
auto current = 1 + golomb[i - golomb[golomb[i - 1]]];
golomb.push_back(current);
products += current * i;
}
#else
// precompute golomb[i] = G(i)
// and sums[i] = G(1) + G(2) + G(3) + ... + G(i)
// and products[i] = 1*G(1) + 2*G(2) + 3*G(3) + ... + i*G(i)
std::vector<unsigned long long> sums = { 0, 1 };
std::vector<unsigned long long> products = { 0, 1 };
// stop when products[i] >= 10^18
for (unsigned long long i = 2; products.back() < cubicLimit; i++)
{
auto current = 1 + golomb[i - golomb[golomb[i - 1]]];
golomb .push_back(current);
sums .push_back(current + sums.back());
products.push_back(current * i + products.back());
}
#endif
// will contain the result
unsigned long long sum = 0;
#ifdef LOW_MEMORY
unsigned long long lastSums = 0;
unsigned long long sums = 1;
unsigned long long lastProducts = 0;
products = 1;
#endif
// find products[index - 1] < i <= products[index]
auto index = 1;
for (unsigned long long i = 1; i < limit; i++)
{
// n = i^3
auto n = i * i * i;
// find products[index - 1] < i <= products[index]
#ifdef LOW_MEMORY
while (products < n)
{
index++;
lastSums = sums;
sums += golomb[index];
lastProducts = products;
products += golomb[index] * index;
}
#else
while (products[index] < n)
index++;
#endif
// note: n will be in ascending order, therefore I re-use index from previous iterations
// in most cases it will be already the correct value
// find linear interpolation between products[index - 1] and products[index]
#ifdef LOW_MEMORY
auto from = lastProducts;
auto to = products;
#else
auto from = products[index - 1];
auto to = products[index];
#endif
auto ratio = (n - from) / double(to - from);
// and apply it to sums[index - 1] and sums[index]
#ifdef LOW_MEMORY
auto low = lastSums;
auto high = sums;
#else
auto low = sums[index - 1];
auto high = sums[index];
#endif
// round up
auto offset = ceil((high - low) * ratio);
// note: convert to integer as soon as possible to avoid losing digits due to double's limited precision
auto result = (unsigned long long)offset + low;
// finished another number ...
sum += result;
}
// solved another problem !
std::cout << sum << std::endl;
return 0;
}
This solution contains 18 empty lines, 25 comments and 18 preprocessor commands.
Benchmark
The correct solution to the original Project Euler problem was found in 0.11 seconds on an Intel® Core™ i7-2600K CPU @ 3.40GHz.
Peak memory usage was about 133 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
August 15, 2017 submitted solution
August 15, 2017 added comments
Difficulty
Project Euler ranks this problem at 45% (out of 100%).
Links
projecteuler.net/thread=341 - the best forum on the subject (note: you have to submit the correct solution first)
Code in various languages:
Python github.com/evilmucedin/project-euler/blob/master/euler341/euler341.py (written by Den Raskovalov)
Python github.com/Meng-Gen/ProjectEuler/blob/master/341.py (written by Meng-Gen Tsai)
C++ github.com/evilmucedin/project-euler/blob/master/euler341/euler341.cpp (written by Den Raskovalov)
C++ github.com/roosephu/project-euler/blob/master/341.cpp (written by Yuping Luo)
Java github.com/thrap/project-euler/blob/master/src/Java/Problem341.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 |
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 336 - Maximix Arrangements | Fractional Sequences - problem 343 >> |