<< problem 83 - Path sum: four ways | Counting rectangles - problem 85 >> |
Problem 84: Monopoly odds
(see projecteuler.net/problem=84)
In the game, Monopoly, the standard board is set up in the following way:
A player starts on the GO square and adds the scores on two 6-sided dice to determine the number of squares they advance in a clockwise direction.
Without any further rules we would expect to visit each square with equal probability: 2.5%.
However, landing on G2J (Go To Jail), CC (community chest), and CH (chance) changes this distribution.
In addition to G2J, and one card from each of CC and CH, that orders the player to go directly to jail, if a player rolls three consecutive doubles,
they do not advance the result of their 3rd roll. Instead they proceed directly to jail.
At the beginning of the game, the CC and CH cards are shuffled. When a player lands on CC or CH they take a card from the top of the respective pile and,
after following the instructions, it is returned to the bottom of the pile.
There are sixteen cards in each pile, but for the purpose of this problem we are only concerned with cards that order a movement;
any instruction not concerned with movement will be ignored and the player will remain on the CC/CH square.
- Community Chest (2/16 cards):
- Chance (10/16 cards):
Go to C1, Go to E3, Go to H2, Go to R1,
Go to next R (railway company), Go to next R, Go to next U (utility company),
Go back 3 squares
The heart of this problem concerns the likelihood of visiting a particular square. That is, the probability of finishing at that square after a roll.
For this reason it should be clear that, with the exception of G2J for which the probability of finishing on it is zero, the CH squares will have the lowest probabilities,
as 5/8 request a movement to another square, and it is the final square that the player finishes at on each roll that we are interested in.
We shall make no distinction between "Just Visiting" and being sent to JAIL, and we shall also ignore the rule about requiring a double to "get out of jail",
assuming that they pay to get out on their next turn.
By starting at GO and numbering the squares sequentially from 00 to 39 we can concatenate these two-digit numbers to produce strings that correspond with sets of squares.
Statistically it can be shown that the three most popular squares, in order, are JAIL (6.24%) = Square 10, E3 (3.18%) = Square 24, and GO (3.09%) = Square 00.
So these three most popular squares can be listed with the six-digit modal string: 102400.
If, instead of using two 6-sided dice, two 4-sided dice are used, find the six-digit modal string.
My Algorithm
Disclaimer: this was one of my least favorite problems so far.
The main idea is to run a Monte-Carlo simulation (see en.wikipedia.org/wiki/Monte_Carlo_method):
roll the dice five million times and count how often you land on each field.
The longer the simulation runs, the closer you get to the true statistical value.
Because I hate this problem so much, there is no further explanation of my code ...
Modifications by HackerRank
You can't solve this problem with my approach: only a true mathematical analysis will give the correct order of all fields
(yes, some of their test cases ask for all 40 fields in descendingly sorted order).
Right now I am not interesting in rewriting my code. Apparently, Markov chains are the way to go (see en.wikipedia.org/wiki/Markov_chain).
Note
I reduced Rolls
from the original 5 million to 1 million otherwise my live tests would time out.
It still solves the original problem but has a lower score at Hackerrank.
Interactive test
You can submit your own input to my program and it will be instantly processed at my server:
This is equivalent toecho "6 3" | ./84
Output:
Note: the original problem's input 4 3
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.
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 <vector>
#include <map>
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <cmath>
int main()
{
// four-sided dices ?
unsigned int diceSize = 4;
std::cin >> diceSize;
// print the 3 most frequent fields
unsigned int showFields = 3;
std::cin >> showFields;
// number of simulated moves
const unsigned int Rolls = 1000000;//50000000;
// always the same random numbers
srand(0);
// board setup
const unsigned int NumFields = 40;
// special field positions
const unsigned int Go = 0;
const unsigned int Jail = 10;
const unsigned int GoToJail = 30;
const unsigned int Community [3] = { 2, 17, 33 };
const unsigned int Chance [3] = { 7, 22, 36 };
const unsigned int NextRailway[3] = { 15, 25, 5 }; // index x corresponds to Chance[x]
const unsigned int NextUtility[3] = { 12, 28, 12 }; // index x corresponds to Chance[x]
// random setup of community and chance cards, give them IDs 0..15
std::vector<unsigned int> chance, community;
for (unsigned int i = 0; i < 16; i++)
{
chance .push_back(i);
community.push_back(i);
}
std::random_shuffle(chance.begin(), chance.end());
std::random_shuffle(community.begin(), community.end());
// Monte-Carlo simulation
unsigned int current = Go;
unsigned int doubles = 0;
std::vector<unsigned long long> count(NumFields, 0);
for (unsigned int rolls = 0; rolls < Rolls; rolls++)
{
// roll the dice ...
unsigned int dice1 = (rand() % diceSize) + 1;
unsigned int dice2 = (rand() % diceSize) + 1;
// next field
unsigned int next = (current + dice1 + dice2) % NumFields;
// double ?
if (dice1 == dice2)
doubles++;
else
doubles = 0;
if (doubles == 3)
{
next = Jail;
doubles = 0;
}
// chance
if (next == Chance[0] || next == Chance[1] || next == Chance[2])
{
// ID of current chance field (needed to figure out next railway / utility)
int id = 0;
if (next == Chance[1])
id = 1;
if (next == Chance[2])
id = 2;
// check card ID of the topmost card
switch (chance.front())
{
case 0: next = Go; break;
case 1: next = Jail; break;
case 2: next = 11; break; // C1
case 3: next = 24; break; // E3
case 4: next = 39; break; // H2
case 5: next = 5; break; // R1
// go back 3 squares (might land on GoToJail, too)
// awkward formula needs to take care of CC1 which redirects to H2
case 6: next = (next + NumFields - 3) % NumFields; break;
case 7: // two railway cards
case 8: next = NextRailway[id]; break;
case 9: next = NextUtility[id]; break;
default: break;
}
// move card to the bottom
std::rotate(chance.begin(), chance.begin() + 1, chance.end());
}
// community
if (next == Community[0] || next == Community[1] || next == Community[2])
{
// check card ID of the topmost card
switch (community.front())
{
case 0: next = Go; break;
case 1: next = Jail; break;
default: break;
}
// move card to the bottom
std::rotate(community.begin(), community.begin() + 1, community.end());
}
if (next == GoToJail)
next = Jail;
count[next]++;
current = next;
}
// normalize (actually not needed, just to ease debugging)
unsigned long long sum = 0;
for (auto x : count)
sum += x;
// use std::map's implicit sorting
std::multimap<double, unsigned int> sorted; // multimap in case of identical probabilities
for (unsigned int i = 0; i < count.size(); i++)
sorted.insert(std::make_pair(count[i] * 100.0 / sum, i));
// extract the field positions
std::vector<unsigned int> result;
for (auto x : sorted)
result.push_back(x.second);
// and show the most frequent ones (they are at the end of the container)
auto i = result.rbegin();
#define ORIGINAL
#ifdef ORIGINAL
for (unsigned int j = 0; j < showFields; j++)
std::cout << std::setw(2) << std::setfill('0') << *i++;
#else
// field names
const char* names[] = { "GO", "A1", "CC1", "A2", "T1", "R1", "B1", "CH1", "B2", "B3",
"JAIL", "C1", "U1", "C2", "C3", "R2", "D1", "CC2", "D2", "D3",
"FP", "E1", "CH2", "E2", "E3", "R3", "F1", "F2", "U2", "F3",
"G2J", "G1", "G2", "CC3", "G3", "R4", "CH3", "H1", "T2", "H2" };
for (unsigned int j = 0; j < showFields; j++)
std::cout << names[*i++] << " ";
#endif
return 0;
}
This solution contains 25 empty lines, 25 comments and 10 preprocessor commands.
Benchmark
The correct solution to the original Project Euler problem was found in 0.05 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
March 17, 2017 submitted solution
May 9, 2017 added comments
Hackerrank
see https://www.hackerrank.com/contests/projecteuler/challenges/euler084
My code solves 11 out of 21 test cases (score: 55%)
I failed 10 test cases due to wrong answers and 0 because of timeouts
Difficulty
Project Euler ranks this problem at 35% (out of 100%).
Hackerrank describes this problem as hard.
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=84 - 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-84-monopoly-popular-squares/ (written by Kristian Edlund)
C# github.com/HaochenLiu/My-Project-Euler/blob/master/084.cs (written by Haochen Liu)
Python github.com/hughdbrown/Project-Euler/blob/master/euler-084.py (written by Hugh Brown)
Python github.com/Meng-Gen/ProjectEuler/blob/master/84.py (written by Meng-Gen Tsai)
Python github.com/nayuki/Project-Euler-solutions/blob/master/python/p084.py (written by Nayuki)
Python github.com/roosephu/project-euler/blob/master/84.py (written by Yuping Luo)
Python github.com/steve98654/ProjectEuler/blob/master/084.py
C++ github.com/zmwangx/Project-Euler/blob/master/084/084.cpp (written by Zhiming Wang)
Java github.com/nayuki/Project-Euler-solutions/blob/master/java/p084.java (written by Nayuki)
Java github.com/thrap/project-euler/blob/master/src/Java/Problem84.java (written by Magnus Solheim Thrap)
Go github.com/frrad/project-euler/blob/master/golang/Problem084.go (written by Frederick Robinson)
Scala github.com/samskivert/euler-scala/blob/master/Euler084.scala (written by Michael Bayne)
Perl github.com/gustafe/projecteuler/blob/master/084-Monopoly-odds.pl (written by Gustaf Erikson)
Rust github.com/gifnksm/ProjectEulerRust/blob/master/src/bin/p084.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 |
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 83 - Path sum: four ways | Counting rectangles - problem 85 >> |