<< problem 183 - Maximum product of parts | Connectedness of a network - problem 186 >> |
Problem 185: Number Mind
(see projecteuler.net/problem=185)
The game Number Mind is a variant of the well known game Master Mind.
Instead of coloured pegs, you have to guess a secret sequence of digits. After each guess you're only told in how many places you've guessed the correct digit.
So, if the sequence was 1234 and you guessed 2036, you'd be told that you have one correct digit; however, you would NOT be told that you also have another digit in the wrong place.
For instance, given the following guesses for a 5-digit secret sequence,
90342 ;2 correct
70794 ;0 correct
39458 ;2 correct
34109 ;1 correct
51545 ;2 correct
12531 ;1 correct
The correct sequence 39542 is unique.
Based on the following guesses,
5616185650518293 ;2 correct
3847439647293047 ;1 correct
5855462940810587 ;3 correct
9742855507068353 ;3 correct
4296849643607543 ;3 correct
3174248439465858 ;1 correct
4513559094146117 ;2 correct
7890971548908067 ;3 correct
8157356344118483 ;1 correct
2615250744386899 ;2 correct
8690095851526254 ;3 correct
6375711915077050 ;1 correct
6913859173121360 ;1 correct
6442889055042768 ;2 correct
2321386104303845 ;0 correct
2326509471271448 ;2 correct
5251583379644322 ;2 correct
1748270476758276 ;3 correct
4895722652190306 ;1 correct
3041631117224635 ;3 correct
1841236454324589 ;3 correct
2659862637316867 ;2 correct
Find the unique 16-digit secret sequence.
My Algorithm
I attempted to solve this problem with constraint-based programming but failed miserably: my ideas were either too slow or plain wrong ...
Then I managed to solve it using simulated annealing:
- start with a random guess and compute its error metric (see
distance()
) - modify single elements randomly and check whether the error is reduced, keep the best mutation
- if mutations fail to improve for a certain time, change an element randomly even if the error gets worse
distance
compares the current sequence against all 22 guesses.My error metric is the sum of all differences between the actually matching digits and the expected number.
For example, comparing
6666666666666666
against the first guess 5616185650518293
finds 3 matching digits, but only 2 were expected → the error is 1.I added a simple pseudo-random generator to ensure that my solution terminates successfully on various compilers (with different implementations of
rand()
).It takes about 0.2 seconds on my machine to find the correct solution.
Let's be honest: the number of iterations without improvement (
MaxRoundsWithoutImprovement = 20
) is fine-tuned to minimize execution time.Changing it to 19 or 21 makes the program significantly slower (more than a second).
And changing the constants of my random-number generator (a few candidates are listed on Wikipedia) may have the same effect.
Interactive test
You can submit your own input to my program and it will be instantly processed at my server:
This live test is based on the Hackerrank problem.
This is equivalent toecho "6 90342 2 70794 0 39458 2 34109 1 51545 2 12531 1" | ./185
Output:
(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.
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>
#include <string>
// all 22 guesses
typedef std::vector<unsigned char> Sequence;
std::vector<Sequence> sequences;
// and how many of their digits match the secret number
std::vector<unsigned int> hits;
// a simple pseudo-random number generator, result in 0 .. modulo - 1
// (produces the same result no matter what compiler you have - unlike rand() from math.h)
unsigned int myrand(unsigned int modulo)
{
static unsigned int seed = 0;
seed = 1103515245 * seed + 12345;
return seed % modulo;
}
// replace reference by a new random digit (0..9)
void shuffle(unsigned char& digit)
{
auto old = digit;
do
digit = myrand(10);
while (digit == old);
}
// a player's guess and how many digits were correct
void add(const std::string& guess, unsigned int matches)
{
// convert from ASCII to int
Sequence s;
for (auto c : guess)
s.push_back(c - '0');
sequences.push_back(s);
hits.push_back(matches);
}
// compute how many digits of the guesses don't match to the currently analyzed number
// a perfect match returns 0, "mismatches" return > 0
unsigned int distance(const Sequence& current)
{
unsigned int errors = 0;
for (unsigned int i = 0; i < sequences.size(); i++)
{
// count number of matching digits
unsigned int same = 0;
for (unsigned int j = 0; j < current.size(); j++)
if (current[j] == sequences[i][j])
same++;
// too many identical digits ?
if (same > hits[i])
errors += same - hits[i];
else // or too few ?
errors += hits[i] - same;
}
return errors;
}
int main()
{
//#define ORIGINAL
#ifdef ORIGINAL
// guesses of the problem
add("5616185650518293", 2);
add("3847439647293047", 1);
add("5855462940810587", 3);
add("9742855507068353", 3);
add("4296849643607543", 3);
add("3174248439465858", 1);
add("4513559094146117", 2);
add("7890971548908067", 3);
add("8157356344118483", 1);
add("2615250744386899", 2);
add("8690095851526254", 3);
add("6375711915077050", 1);
add("6913859173121360", 1);
add("6442889055042768", 2);
add("2321386104303845", 0);
add("2326509471271448", 2);
add("5251583379644322", 2);
add("1748270476758276", 3);
add("4895722652190306", 1);
add("3041631117224635", 3);
add("1841236454324589", 3);
add("2659862637316867", 2);
#else
unsigned int numGuesses;
std::cin >> numGuesses;
while (numGuesses--)
{
std::string guess;
unsigned int correct;
std::cin >> guess >> correct;
add(guess.c_str(), correct);
}
#endif
// initially a purely random guess
const auto NumDigits = sequences.front().size();
Sequence current(NumDigits, 0);
for (auto& x : current)
shuffle(x);
// shuffle a random digit when stuck in a local optimum, too
const auto MaxRoundsWithoutImprovement = 20; // "sweet spot" for my random number generator
auto quietRounds = 0;
auto errors = distance(current);
auto previous = errors;
while (errors != 0)
{
// replace every digit by a different random number, keep those that minimize the error metric
for (auto& digit : current)
{
// replace by a new random digit
auto previousDigit = digit;
do
shuffle(digit);
while (digit == previousDigit);
// compute error metric
auto modified = distance(current);
if (modified <= errors)
{
// better than before, adjust error level and keep new digit
errors = modified;
}
else
// mutation is equal or worse, restore old digit
digit = previousDigit;
}
// unchanged score ? we didn't improve on the previous solution ...
if (errors == previous)
{
// stuck too long ? try to escape local optimum
quietRounds++;
if (quietRounds == MaxRoundsWithoutImprovement)
{
// change a random number
shuffle(current[myrand(current.size())]);
errors = distance(current);
// reset counter
quietRounds = 0;
}
}
else
{
// we got closer to the goal ...
quietRounds = 0;
previous = errors;
}
}
// show solution
for (auto c : current)
std::cout << int(c);
std::cout << std::endl;
return 0;
}
This solution contains 18 empty lines, 26 comments and 6 preprocessor commands.
Benchmark
The correct solution to the original Project Euler problem was found in 0.18 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
May 30, 2017 submitted solution
May 30, 2017 added comments
August 8, 2017 modified to solve Hackerrank, too
Hackerrank
see https://www.hackerrank.com/contests/projecteuler/challenges/euler185
My code solves 21 out of 21 test cases (score: 100%)
Difficulty
Project Euler ranks this problem at 55% (out of 100%).
Hackerrank describes this problem as medium.
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=185 - the best forum on the subject (note: you have to submit the correct solution first)
Code in various languages:
Python github.com/smacke/project-euler/blob/master/python/185.py (written by Stephen Macke)
Java github.com/HaochenLiu/My-Project-Euler/blob/master/185.java (written by Haochen Liu)
Java github.com/thrap/project-euler/blob/master/src/Java/Problem185.java (written by Magnus Solheim Thrap)
Go github.com/frrad/project-euler/blob/master/golang/Problem185.go (written by Frederick Robinson)
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 |
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 |
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 183 - Maximum product of parts | Connectedness of a network - problem 186 >> |