<< problem 112 - Bouncy numbers | Counting block combinations I - problem 114 >> |
Problem 113: Non-bouncy numbers
(see projecteuler.net/problem=113)
Working from left-to-right if no digit is exceeded by the digit to its left it is called an increasing number; for example, 134468.
Similarly if no digit is exceeded by the digit to its right it is called a decreasing number; for example, 66420.
We shall call a positive integer that is neither increasing nor decreasing a "bouncy" number; for example, 155349.
As n increases, the proportion of bouncy numbers below n increases such that there are only 12951 numbers below one-million
that are not bouncy and only 277032 non-bouncy numbers below 10^10.
How many numbers below a googol (10^100) are not bouncy?
My Algorithm
My solution is based on a dynamic programming approach:
- solve the problem for one digit
- solve the problem for n+1 digits by using information from n digits
increase
and decrease
with 1s.Each of their entries represents how many numbers starting with a digit are not bouncy.
In
increase[x][y]
you find the count of increasing numbers with x
digits, where the front-most digit is y
.In each iteration,
increase
and decrease
are updated:increase[x][y]
is the sum of all increase[x-1][less than or equal to y]
(and the other way around for decrease
, too).All not bouncy numbers are either increasing or decreasing. I have to deduct all increasing numbers where the first digit is zero.
On top of that, numbers where all digits are identical are both increasing und decreasing and counted twice, therefore I have to subtract 10.
Modifications by HackerRank
More than 100 digits are no problem. The result will be a rather large number and has to be printed mod 10^9 + 7.
Interactive test
You can submit your own input to my program and it will be instantly processed at my server:
This is equivalent toecho "1 10" | ./113
Output:
Note: the original problem's input 100
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.
The code contains #ifdef
s 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 <iostream>
#include <vector>
// print result modulo some value
#define ORIGINAL
#ifdef ORIGINAL
const unsigned long long Modulo = 1000000000000000000ULL; // high enough to keep the result unchanged
#else
const unsigned long long Modulo = 1000000007ULL;
#endif
int main()
{
// Googol = 100, but Hackerrank wants more ...
const unsigned int numDigits = 100000;
std::vector<unsigned long long> solutions(numDigits + 1, 0);
// count how many numbers are increasing and/or decreasing
typedef unsigned long long DigitCounter[10]; // some older GCC complain about using this in a vector
std::vector<DigitCounter> increase(numDigits);
std::vector<DigitCounter> decrease(numDigits);
// all one-digit numbers are non-bouncy
unsigned long long sum = 9;
for (auto& x : increase[0])
x = 1;
for (auto& x : decrease[0])
x = 1;
// process digits, beginning from the right side
for (unsigned int i = 1; i < numDigits; i++)
{
// digits 0..9
for (unsigned int current = 0; current <= 9; current++)
{
// add count of all numbers where the next digit is equal or lower
decrease[i][current] = 0;
for (unsigned int smaller = 0; smaller <= current; smaller++)
decrease[i][current] = (decrease[i][current] + decrease[i - 1][smaller]) % Modulo;
// add count of all numbers where the next digit is equal or higher
increase[i][current] = 0;
for (unsigned int bigger = current; bigger <= 9; bigger++)
increase[i][current] = (increase[i][current] + increase[i - 1][bigger]) % Modulo;
}
// compute total sum of increasing and decreasing numbers
for (auto x : increase[i])
sum += x;
for (auto x : decrease[i])
sum += x;
// but numbers must not start with zero !
sum -= increase[i][0];
// numbers with identical digits were counted twice
// because they are both increasing and decreasing (e.g. 55555555)
sum -= 10;
// Hackerrank only
sum %= Modulo;
solutions[i] = sum;
}
// lookup results
unsigned int tests;
std::cin >> tests;
while (tests--)
{
unsigned int digits;
std::cin >> digits;
std::cout << solutions[digits - 1] << std::endl; // 0-based array but 1-based input
}
return 0;
}
This solution contains 12 empty lines, 14 comments and 6 preprocessor commands.
Benchmark
The correct solution to the original Project Euler problem was found in 0.02 seconds on an Intel® Core™ i7-2600K CPU @ 3.40GHz.
Peak memory usage was about 18 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
May 15, 2017 submitted solution
May 22, 2017 added comments
Hackerrank
see https://www.hackerrank.com/contests/projecteuler/challenges/euler113
My code solves 3 out of 3 test cases (score: 30%)
Difficulty
Project Euler ranks this problem at 30% (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 rarely an option.
Links
projecteuler.net/thread=113 - the best forum on the subject (note: you have to submit the correct solution first)
Code in various languages:
C# www.mathblog.dk/project-euler-113-googol-not-bouncy/ (written by Kristian Edlund)
C# github.com/HaochenLiu/My-Project-Euler/blob/master/113.cs (written by Haochen Liu)
Python github.com/nayuki/Project-Euler-solutions/blob/master/python/p113.py (written by Nayuki)
Python github.com/steve98654/ProjectEuler/blob/master/113.py
C++ github.com/Meng-Gen/ProjectEuler/blob/master/113.cc (written by Meng-Gen Tsai)
C github.com/LaurentMazare/ProjectEuler/blob/master/e113.c (written by Laurent Mazare)
Java github.com/dcrousso/ProjectEuler/blob/master/PE113.java (written by Devin Rousso)
Java github.com/nayuki/Project-Euler-solutions/blob/master/java/p113.java (written by Nayuki)
Java github.com/thrap/project-euler/blob/master/src/Java/Problem113.java (written by Magnus Solheim Thrap)
Go github.com/frrad/project-euler/blob/master/golang/Problem113.go (written by Frederick Robinson)
Mathematica github.com/nayuki/Project-Euler-solutions/blob/master/mathematica/p113.mathematica (written by Nayuki)
Mathematica github.com/steve98654/ProjectEuler/blob/master/113.nb
Haskell github.com/nayuki/Project-Euler-solutions/blob/master/haskell/p113.hs (written by Nayuki)
Perl github.com/gustafe/projecteuler/blob/master/113-Non-bouncy-numbers.pl (written by Gustaf Erikson)
Perl github.com/shlomif/project-euler/blob/master/project-euler/113/euler-113.pl (written by Shlomi Fish)
Rust github.com/gifnksm/ProjectEulerRust/blob/master/src/bin/p113.rs
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 |
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 112 - Bouncy numbers | Counting block combinations I - problem 114 >> |