<< problem 226 - A Scoop of Blancmange | Four Representations using Squares - problem 229 >> |
Problem 227: The Chase
(see projecteuler.net/problem=227)
"The Chase" is a game played with two dice and an even number of players.
The players sit around a table; the game begins with two opposite players having one die each.
On each turn, the two players with a die roll it.
If a player rolls a 1, he passes the die to his neighbour on the left; if he rolls a 6, he passes the die to his neighbour on the right;
otherwise, he keeps the die for the next turn.
The game ends when one player has both dice after they have been rolled and passed; that player has then lost.
In a game with 100 players, what is the expected number of turns the game lasts?
Give your answer rounded to ten significant digits.
My Algorithm
The expected number of turns can be computed as:
1 * p(1) + 2 * p(2) + 3 * p(3) + ... + n * p(n)
where p(n) is the probability that the two dices arrive at the same player after n rounds.
My program tracks the distance between the two players with a dice.
The vector last[i]
contains the probability that the dices are i
units apart.
Initially they are 100 / 2 = 50 units away from each other therefore last[i] = 0
except last[50] = 1
.
In the following iterations the program repeatedly looks at each last[i]
:
- in 1/36 of all cases player 1 rolls a 1 and player 2 rolls a 6 → the distance is reduced by 2
- in 8/36 of all cases the distance is reduced by 1 (one player rolls 2/3/4/5, the other moves one unit closer)
- in 18/36 of all cases the distance remains unchanged (both roll 2/3/4/5 or both dices move into the same direction)
- in 8/36 of all cases the distance is increased by 1 (one player rolls 2/3/4/5, the other moves one unit away)
- in 1/36 of all cases the distance is icnreased by 2 (roll 6 and 1)
- the distance can't be more than 50: if the players were 49 units apart then moving two units apart actually means that the distance remains unchanged
- the distance can't be less than 0: if the players were 1 unit apart then moving two units closer actually means that the distance remains unchanged
Alternative Approaches
My first code was a bit buggy (I didn't think through all edge cases) and therefore wrote a simpler algorithm that matched my Monte-Carlo results:
two nested loops just roll out all combinations which simplifies things a lot. It's about 4x slower but still finishes in less than 0.2 seconds.
Use the #define FAST
to switch between my final code (FAST
in enabled by default) and that simpler and somehow even more beautiful code.
Note
The function monteCarlo
is a simple Monte Carlo simulation that produces surprisingly accurate results.
The program stops if sufficient precision has been reached. The value of Epsilon
was chosen manually by observing when the result stabilized.
It's optimized for 100 players may be a bit off when running live tests with a different number of players.
Interactive test
You can submit your own input to my program and it will be instantly processed at my server:
This is equivalent toecho 10 | ./227
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.
#include <iostream>
#include <iomanip>
#include <vector>
// ---------- Monte Carlo simulation ----------
// note: not used anymore, I wrote it to generate a good approximation of the result
// a simple pseudo-random number generator
// (produces the same result no matter what compiler you have - unlike rand() from math.h)
unsigned int myrand()
{
static unsigned long long seed = 0;
seed = 6364136223846793005ULL * seed + 1;
return (unsigned int)(seed >> 30);
}
// estimate result with a Monte Carlo simulation
double monteCarlo(unsigned int players, unsigned int iterations)
{
// count rolls
unsigned int rolls = 0;
for (unsigned int i = 0; i < iterations; i++)
{
// initial positions: opposite sides of the table
unsigned int player1 = 0;
unsigned int player2 = players / 2;
// both dices at same position?
while (player1 != player2)
{
// roll first dice
auto dice1 = (myrand() % 6) + 1;
// and move the dice to a neighbor
if (dice1 == 1)
player1 = (player1 + players - 1) % players;
if (dice1 == 6)
player1 = (player1 + 1) % players;
// roll second dice
auto dice2 = (myrand() % 6) + 1;
// and move the dice to a neighbor
if (dice2 == 1)
player2 = (player2 + players - 1) % players;
if (dice2 == 6)
player2 = (player2 + 1) % players;
rolls++;
}
}
return rolls / double(iterations);
}
// I thought I needed long double but the standard double works perfectly (while float fails)
typedef double Number;
int main()
{
// number of players
unsigned int players = 100;
std::cin >> players;
// abort if result stabilized
const auto Epsilon = 0.00000000001;
// before the first round, the dices are always players/2 units apart (always means 100%)
std::vector<Number> last(players / 2 + 1, 0);
last.back() = 1;
// expected = 1 * probability(finished after 1 iteration) +
// 2 * probability(finished after 2 iterations) +
// 3 * probability(finished after 3 iterations) +
// 4 * probability(finished after 4 iterations) + ...
Number expected = 0;
for (unsigned int iteration = 1; ; iteration++) // no abort condition
{
// probabilities after this iteration
std::vector<Number> next(last.size(), 0);
// analyze each distance except 0 (because those are already finished and not relevant for the next iteration)
for (size_t current = 1; current < last.size(); current++)
{
#define FAST
#ifdef FAST
// probability of moving two positions closer (roll 1 plus 6)
auto minus2 = 1.0 / 36;
// probability of moving one position closer (roll 1 plus 2/3/4/5 or 2/3/4/5 plus 6)
auto minus1 = 8.0 / 36;
// probability that distance of dices remains unchanged (roll 2/3/4/5 plus 2/3/4/5 or 1 plus 1 or 6 plus 6)
auto same = 18.0 / 36;
// probability of moving one position away (roll 6 plus 2/3/4/5 or 2/3/4/5 plus 1)
auto plus1 = 8.0 / 36;
// probability of moving two positions away (roll 6 plus 1)
auto plus2 = 1.0 / 36;
// if dices were one position away from each other, then dices could pass each other
if (current == 1)
{
// dices are still one position away (but they swapped their places)
same += minus2;
minus2 = 0;
}
else
// same concept as current == 1 but this time dices were on opposite sides of the table
if (current == 49)
{
same += plus2;
plus2 = 0;
}
else
// dices are the farthest away - each move brings them closer
if (current == 50)
{
minus2 += plus2;
minus1 += plus1;
plus2 = 0;
plus1 = 0;
}
// perform all possible moves (if allowed):
// two steps closer
if (current >= 2)
next[current - 2] += minus2 * last[current];
// one step closer
next[current - 1] += minus1 * last[current];
// unchanged
next[current ] += same * last[current];
// one step away
if (current + 1 < next.size())
next[current + 1] += plus1 * last[current];
// two steps away
if (current + 2 < next.size())
next[current + 2] += plus2 * last[current];
#else
// slower but simpler approach
for (auto dice1 = 1; dice1 <= 6; dice1++)
for (auto dice2 = 1; dice2 <= 6; dice2++)
{
// find next distance after rolling both dices
int destination = (int)current; // might become negative, therefore signed value
if (dice1 == 1)
destination--;
if (dice1 == 6)
destination++;
if (dice2 == 1)
destination++;
if (dice2 == 6)
destination--;
// reached minimum / maximum distance ?
if (destination == -1)
destination = +1;
if (destination > (int)players / 2)
destination = players - destination;
// add probabilities
next[destination] += 1.0 / (6*6) * last[current];
}
#endif
}
// iteration is finished, copy probabilities
last = std::move(next);
// look at last[0] (=> probability of finishing after this iteration)
auto finished = last.front();
// add to expected value
auto delta = finished * iteration;
expected += delta;
// enough precision ?
if (iteration > players * players && delta < Epsilon) // note: first iterations have delta = 0, dont stop too early
break;
}
// print result
std::cout << std::fixed << std::setprecision(10 - 4) // 10 digits: 6 in front of the decimal separator plus 4 after it
<< expected << std::endl;
// run Monte Carlo simulation
//while (true)
//std::cout << monteCarlo(100, 10000) << std::endl;
return 0;
}
This solution contains 30 empty lines, 49 comments and 7 preprocessor commands.
Benchmark
The correct solution to the original Project Euler problem was found in 0.03 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 24, 2017 submitted solution
August 24, 2017 added comments
Difficulty
Project Euler ranks this problem at 65% (out of 100%).
Links
projecteuler.net/thread=227 - the best forum on the subject (note: you have to submit the correct solution first)
Code in various languages:
Python github.com/hughdbrown/Project-Euler/blob/master/euler-227.py (written by Hugh Brown)
Python github.com/Meng-Gen/ProjectEuler/blob/master/227.py (written by Meng-Gen Tsai)
Python github.com/smacke/project-euler/blob/master/python/227.py (written by Stephen Macke)
C++ github.com/roosephu/project-euler/blob/master/227.cpp (written by Yuping Luo)
Java github.com/thrap/project-euler/blob/master/src/Java/Problem227.java (written by Magnus Solheim Thrap)
Go github.com/frrad/project-euler/blob/master/golang/Problem227.go (written by Frederick Robinson)
Mathematica github.com/frrad/project-euler/blob/master/mathematica/Problem227.m (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 | 617 | 618 |
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 226 - A Scoop of Blancmange | Four Representations using Squares - problem 229 >> |