<< problem 485 - Maximum number of divisors | Under The Rainbow - problem 493 >> |
Problem 491: Double pandigital number divisible by 11
(see projecteuler.net/problem=491)
We call a positive integer double pandigital if it uses all the digits 0 to 9 exactly twice (with no leading zero).
For example, 40561817703823564929 is one such number.
How many double pandigital numbers are divisible by 11?
My Algorithm
bruteForce
counts all permutations which are divisible by 11.
It finds the correct result in a reasonable amount of time when the highest digit is 6.
And of course that simple approach is way to slow when the highest digit is 9.
A number is divisible by 11 if the difference of the sum of the digits at odd and the even positions is divisible by 11.
40561817703823564929 is not divisible by 11 because 4+5+1+1+7+0+2+5+4+2 = 31 and 0+6+8+7+0+8+3+6+9+9 = 56 and 56 - 31= 25 is not divisible by 11.
There is actually an astonishing variety of rules for divisibility by 11: en.wikipedia.org/wiki/Divisibility_rule
All double pandigital numbers are permutations of the string "00112233445566778899"
(excluding leading zeros).
Ten of these digits will be at odd positions and ten at even positions.
If I create a bitmask which digits will be at odd positions then I need a 20-bit integer where exactly 10 bits are set.
All bitmasks with exactly 10 bits set are between 00000000001111111111b (minBitmask
) and 11111111110000000000b (maxBitmask
).
The nice function nextNumberWithSameBits(x)
creates the next number with the same number of bits set as x
and was first published in HAKMEM 175 (often called "snoob").
However, there are a few bordercases:
I can choose a digit once, twice or not at all to appear at an odd position. A bitmask might be:
99887766554433221100
01001101010111000101
→ exactly 10 bits set
For each digit I must only accept the bit patterns:
01 (=> use that digit once, e.g. for 9,6,...),
11 (twice, e.g. for 7 and 3) and
00 (none, e.g. for 8 and 2)
I must not accept bit pattern 10 because it's the same as 01 (see my loop with the variable reduce
).
The sum of all digits is 2 * T(9) where T is the triangular number:
digitSum = 2 * dfrac{9 * (9 + 1)}{2} = 90
The sum of all digits at even positions can be computed when I know the sum of all digits at odd positions:
sumEven = digitSum - sumOdd
And the difference of sumEven and sumOdd has to be divisible by 11:
(sumEven - sumOdd) == 0 mod 11
((digitSum - sumOdd) - sumOdd) == 0 mod 11
(digitSum - 2 * sumOdd) == 0 mod 11
Whenever I know that the bitmasks generate matching numbers I have to figure out how many different numbers are possible.
If x_i represents how often x appears at odd positions then x_i can be either 0, 1 or 2.
The total number of permutations will be:
p(x) = dfrac{10!}{x_0!x_1!x_2!...x_9!}
If y_i represents how often y appears at even positions then y_i can be either 0, 1 or 2. The formula remains the same:
p(y) = dfrac{10!}{y_0!y_1!y_2!...y_9!}
And the sum of all p(x)p(y) will be the result.
Interesting is that the number of digits that appear twice is the same for p(x) and p(y). Even though a few x_i != y_i, it's still p(x) = p(y).
There my code simplifies to result += permutationsRepeated[repeated] * permutationsRepeated[repeated];
Excluding leading zeros is simple: just multiply with frac{9}{10}.
Interactive test
You can submit your own input to my program and it will be instantly processed at my server:
This is equivalent toecho 3 | ./491
Output:
Note: the original problem's input 9
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 <string>
#include <algorithm>
#include <cstdlib>
// count all numbers, where highest digit is maxDigit
unsigned long long bruteForce(unsigned int maxDigit)
{
unsigned long long result = 0;
// keep only a few digits
std::string digits = "10012233445566778899"; // smallest number without a leading zero
digits.resize(maxDigit * 2 + 2);
// count numbers divisible by 11
do
{
if (std::stoll(digits) % 11 == 0)
result++;
} while (std::next_permutation(digits.begin(), digits.end()));
return result;
}
// return next higher number with same number of bits set
unsigned int nextNumberWithSameBits(unsigned int x)
{
// from HAKMEM 175
// see http://www.hackersdelight.org/hdcodetxt/snoob.c.txt
auto smallest = x & -x;
auto ripple = x + smallest;
auto ones = ripple ^ x;
return ((ones >> 2) / smallest) | ripple;
}
// count numbers by using permutations
unsigned long long fast(unsigned int maxDigit)
{
unsigned long long result = 0;
int digitSum = 2 * (maxDigit + 1) * maxDigit / 2; // = (maxDigit + 1) * maxDigit = 90
auto numDigits = 2 * (maxDigit + 1); // = 20
// precompute number of permutations with repeated elements
unsigned long long factorial = 1;
for (unsigned int i = 1; i <= maxDigit + 1; i++)
factorial *= i; // 10! = 3628800
// 10!, 10!/2!, 10!/2!2!, 10!/2!2!2!, ...
unsigned long long permutationsRepeated[10];
for (unsigned int i = 0; i <= maxDigit; i++)
permutationsRepeated[i] = factorial >> i;
// smallest bitmask where maxDigits bits are set
auto minBitmask = (1 << (maxDigit + 1)) - 1;
// largest bitmask where maxDigits bits are set
auto maxBitmask = minBitmask << (maxDigit + 1);
// process all bitmasks where maxDigits bits are set
for (auto bitmask = minBitmask; bitmask <= maxBitmask; bitmask = nextNumberWithSameBits(bitmask))
{
// when picking a number for odd positions:
// choose a digit once, twice or not at all
// e.g. bits represent 99887766554433221100
// and the current choice might be 01001101010111000101
// (exactly 10 bits set)
// for each digit only accept the bit patterns 01 (once, e.g. for 9,6,...),
// 11 (twice, e.g. for 7 and 3) and
// 00 (none, e.g. for 8 and 2)
// DO NOT accept 10 because it's the same as 01
// ok will be false if bit pattern 10 is found
auto reduce = bitmask;
bool ok = true;
while (reduce > 0)
{
// lowest two bits are 10b (=2 decimal) ?
if ((reduce & 3) == 2)
{
ok = false;
break;
}
// next two bits
reduce >>= 2;
}
if (!ok)
continue;
// add all digits at odd positions and count how many digits are repeatedly present at odd positions
int sumOdd = 0;
auto repeated = 0; // it's actually the same value for odd and even positions
for (unsigned int pos = 0; pos < numDigits; pos++)
{
// bit set ? use that digit
if (bitmask & (1 << pos))
{
sumOdd += pos / 2;
// use that digit twice ? (bit pattern 11b)
if (pos & 1) // same as repeated += pos & 1;
repeated++;
}
}
// divisible by 11 ?
if ((digitSum - 2*sumOdd) % 11 == 0)
result += permutationsRepeated[repeated] * permutationsRepeated[repeated];
}
// exclude leading zeros
return result * maxDigit / (maxDigit + 1);
}
int main()
{
unsigned int numDigits = 9;
std::cin >> numDigits;
//std::cout << bruteForce(numDigits) << std::endl;
std::cout << fast(numDigits) << std::endl;
return 0;
}
This solution contains 15 empty lines, 30 comments and 4 preprocessor commands.
Benchmark
The correct solution to the original Project Euler problem was found in less than 0.01 seconds on an Intel® Core™ i7-2600K CPU @ 3.40GHz.
(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 16, 2017 submitted solution
August 16, 2017 added comments
Difficulty
Project Euler ranks this problem at 20% (out of 100%).
Links
projecteuler.net/thread=491 - 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/491.py (written by Meng-Gen Tsai)
Python github.com/smacke/project-euler/blob/master/python/491.py (written by Stephen Macke)
C++ github.com/evilmucedin/project-euler/blob/master/euler491/euler491.cpp (written by Den Raskovalov)
Perl github.com/shlomif/project-euler/blob/master/project-euler/491/euler-491-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 |
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 485 - Maximum number of divisors | Under The Rainbow - problem 493 >> |