<< problem 250 - 250250 | Stone Game - problem 260 >> |
Problem 259: Reachable Numbers
(see projecteuler.net/problem=259)
A positive integer will be called reachable if it can result from an arithmetic expression obeying the following rules:
- Uses the digits 1 through 9, in that order and exactly once each.
- Any successive digits can be concatenated (for example, using the digits 2, 3 and 4 we obtain the number 234).
- Only the four usual binary arithmetic operations (addition, subtraction, multiplication and division) are allowed.
- Each operation can be used any number of times, or not at all.
- Unary minus is not allowed.
- Any number of (possibly nested) parentheses may be used to define the order of operations.
What is the sum of all positive reachable integers?
My Algorithm
I wrote a very basic struct Fraction
to represent a rational number. It supports addition, multiplication, division and comparison.
It doesn't care about signs, division-by-zero and so on.
My search
function returns all fractions that can be generated by splitting its std::string
parameter in any possible way
and applying any allowed operation:
- it splits its input into two parts
- then calls itself recursively to get all fractions generated by the left part and by the right part
- two nested loops add, subtract, multiply and divide all fractions from the left part with all fractions from the right part
- invalid things, like division-by-zero, are rejected and subtraction is simulated by adding with a negated numerator
- there might be several combinations that produce the same result, therefore the output is sorted and
std::unique
ensures only unique fractions are left - (I don't reduce fractions and so it's possible to have the same fraction multiple times if their numerators and denominators differ by a factor)
main
has to check whether these fractions are positive integers.And finally all duplicates are removed and the sum of all unique integers is displayed.
Interactive test
You can submit your own input to my program and it will be instantly processed at my server:
This is equivalent toecho 4 | ./259
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 <vector>
#include <algorithm>
// a rational number
// fractions are neither reduced nor is the sign kept consistent
// (both numerator and denominator might be negative)
struct Fraction
{
// create a new number
Fraction(unsigned int numerator_, unsigned int denominator_ = 1)
: numerator(numerator_), denominator(denominator_)
{}
// add
Fraction operator+(const Fraction& other) const
{
return Fraction(numerator * other.denominator + other.numerator * denominator,
denominator * other.denominator);
}
// multiply
Fraction operator*(const Fraction& other) const
{
return Fraction(numerator * other.numerator,
denominator * other.denominator);
}
// divide
Fraction operator/(const Fraction& other) const
{
return Fraction(numerator * other.denominator,
denominator * other.numerator);
// note: I don't attempt to reduce the fraction
}
// for std::sort
bool operator<(const Fraction& other) const
{
return numerator * other.denominator < denominator * other.numerator;
}
// for std::unique
bool operator==(const Fraction& other) const
{
return numerator * other.denominator == denominator * other.numerator;
}
// both might have a negative sign
int numerator;
int denominator;
};
// return all rational numbers that can be produced by the sequence of digits
std::vector<Fraction> search(const std::string& digits)
{
// if no operations are applied, then all digits might be a single number
std::vector<Fraction> result = { Fraction(std::stod(digits)) };
// split digits into two parts and apply an operation on them
for (size_t split = 1; split < digits.size(); split++)
{
auto left = digits.substr(0, split);
auto right = digits.substr(split);
// recursively find all fractions that can be created with these parts
auto leftFractions = search(left);
auto rightFractions = search(right);
// merge both with + - * /
for (auto x : leftFractions)
for (auto y : rightFractions)
{
// add
result.push_back(x + y);
// subtract: not really implemented, just negate second number's numerator and then add
result.push_back(x + Fraction(-y.numerator, y.denominator));
// multiply
result.push_back(x * y);
// divide: disallow division by zero
if (y.numerator != 0)
result.push_back(x / y);
}
}
// prune redundant values (makes the code about 10x faster !)
if (result.size() > 1)
{
std::sort(result.begin(), result.end());
auto last = std::unique(result.begin(), result.end());
result.erase(last, result.end());
}
return result;
}
int main()
{
unsigned int lastDigit = 9;
std::cin >> lastDigit;
// create a string with all digits in ascending order (from 1 to lastDigit)
std::string digits = "123456789";
digits = digits.substr(0, lastDigit);
// find all possible fractions
auto fractions = search(digits);
// all found values
std::vector<int> found;
// extract all integers from these fractions
for (auto current: fractions)
{
// remove negative sign from denominator
if (current.denominator < 0)
{
current.numerator *= -1;
current.denominator *= -1;
}
// fraction must be positive
if (current.numerator <= 0)
continue;
// numerator must be a multiple of its denominator (=> fraction must be an integer)
if (current.numerator % current.denominator == 0)
found.push_back(current.numerator / current.denominator);
}
// remove duplicates
std::sort(found.begin(), found.end());
auto last = std::unique(found.begin(), found.end());
found.erase(last, found.end());
// add all
unsigned long long sum = 0;
for (auto x : found)
sum += x;
// show result
std::cout << sum << std::endl;
return 0;
}
This solution contains 20 empty lines, 31 comments and 4 preprocessor commands.
Benchmark
The correct solution to the original Project Euler problem was found in 1.5 seconds on an Intel® Core™ i7-2600K CPU @ 3.40GHz.
Peak memory usage was about 139 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
July 4, 2017 submitted solution
July 4, 2017 added comments
Difficulty
Project Euler ranks this problem at 70% (out of 100%).
Links
projecteuler.net/thread=259 - the best forum on the subject (note: you have to submit the correct solution first)
Code in various languages:
Python github.com/LaurentMazare/ProjectEuler/blob/master/e259.py (written by Laurent Mazare)
Python github.com/Meng-Gen/ProjectEuler/blob/master/259.py (written by Meng-Gen Tsai)
Python github.com/roosephu/project-euler/blob/master/259.py (written by Yuping Luo)
Python github.com/smacke/project-euler/blob/master/python/259.py (written by Stephen Macke)
Java github.com/thrap/project-euler/blob/master/src/Java/Problem259.java (written by Magnus Solheim Thrap)
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 | 619 | 620 | 621 | 622 |
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 250 - 250250 | Stone Game - problem 260 >> |