<< problem 268 - Counting numbers with at least four distinct ... | Divisibility Multipliers - problem 274 >> |
Problem 273: Sum of Squares
(see projecteuler.net/problem=273)
Consider equations of the form: a^2 + b^2 = N, 0 <= a <= b, a, b and N integer.
For N=65 there are two solutions:
a=1, b=8 and a=4, b=7.
We call S(N) the sum of the values of a of all solutions of a^2 + b^2 = N, 0 <= a <= b, a, b and N integer.
Thus S(65) = 1 + 4 = 5.
Find sum{S(N)}, for all squarefree N only divisible by primes of the form 4k+1 with 4k+1 < 150.
My Algorithm
Fermat found that an odd prime is expressible as (see en.wikipedia.org/wiki/Fermat's theorem on sums of two squares):
(1) p = x^2 + y^2
only if p == 1 (mod 4). Written in a different way: each prime which can be represented as 4k+1 has a unique solution x^2 + y^2.
Honestly, I took me a few seconds to understand the very last sentence:
- I have to find all primes below 150 where 4k+1
- N stands for any product of the primes (where each prime is used at most once)
- e.g. (4 * 1 + 1) * (4 * 3 + 1) = 5 * 13 = 65
The function
is4n1Prime()
returns true if p is such a prime.processPrime()
is almost identical to the brute-force algorithm and finds the unique representation of a prime by two squares.It's superfast because the relevant primes are so small.
If p_1 = a^2 + b^2 and p_2 = c^2 + d^2 then the product of those two primes is:
(2) p_1 p_2 = (a^2 + b^2) * (c^2 + d^2)
(3) p_1 p_2 = a^2 c^2 + a^2 d^2 + b^2 c^2 + b^2 d^2
Adding and subtracting 2abcd as well as rearranging the terms:
(4a) p_1 p_2 = a^2 c^2 + 2abcd + b^2 d^2 + a^2 d^2 - 2abcd + b^2 c^2
(5a) p_1 p_2 = (ac + bd)^2 + (ad - bc)^2
And a second variation:
(4b) p_1 p_2 = a^2 c^2 - 2abcd + b^2 d^2 + a^2 d^2 + 2abcd + b^2 c^2
(5b) p_1 p_2 = (ac - bd)^2 + (ad + bc)^2
This is known as the Brahmagupta-Fibonacci identity (see en.wikipedia.org/wiki/Brahmagupta–Fibonacci identity)
Now I know that each product of two primes has the solutions
(6) p_1 p_2 = x^2 + y^2
(7a) x_1 = ac + bd and y_1 = | ad - bc |
(7b) x_2 = | ac - bd | and y_2 = ad - bc
A product of three primes p_1 p_2 p_3 can be solved by solving the product p_1 p_2 and then using both solutions together with p_3.
In the same way, any product of j primes can be solved by solving the case of j-1 primes first and then including the next prime.
The function
search()
combines a bunch of solutions with one more prime in a recursive manner.To simplify finding the smaller square it always ensure that the first square is smaller than the second.
I had to spent a few minutes thinking of a proper initial input value for
search()
and came up with Seed = { 1, 0 }
:- combining any prime's sum of square with this constant returns the same sum of squares
- there is only one solution, not two, when doing so
- it's possible that my algorithm combines zero primes →
Seed
is part of the result set and has to be ignored
Alternative Approaches
A smarter implementation can get rid of the "temporary" container solutions
.
Note
To my surprise, my code didn't work because std::abs
is apparently not defined for long long
in my compiler's standard library.
The simple template abs
is a no-brainer - but I'm still confused by the improper implementation of std::abs
.
My original code contained a few lines of debugging output. For example, it printed the product of primes currently analyzed.
Those numbers easily exceed 64 bits (but 128 bits would be sufficient). Therefore my 64 bit output was wrong and I thought I had a serious bug in my algorithm.
Interactive test
You can submit your own input to my program and it will be instantly processed at my server:
This is equivalent toecho 30 | ./273
Output:
Note: the original problem's input 150
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 <vector>
#include <algorithm>
// store a and b for n = a^2 + b^2 where a<b
typedef std::pair<long long, long long> SumSquares;
// initial dummy element
const SumSquares Seed({ 1, 0 });
// unique representations of primes p = 4n+1
std::vector<SumSquares> primes;
// enumerate all representations and return sum of the smaller part
unsigned int bruteForce(unsigned int n)
{
unsigned int result = 0;
for (unsigned int b = 1; b*b < n; b++)
for (unsigned int a = 1; a < b; a++)
if (a*a + b*b == n)
result += a;
return result;
}
// return true, if p = 4n+1 and p is prime
bool is4n1Prime(unsigned int p)
{
// https://en.wikipedia.org/wiki/Fermat%27s_theorem_on_sums_of_two_squares
// must be 4n+1
if (p % 4 != 1)
return false;
// and prime
for (auto i = 3; i*i <= p; i += 2)
if (p % i == 0)
return false;
// all tests passed (reject p = 1)
return p > 1;
}
// there is a unique sum a^2 + b^2 for each prime p = 4n+1
SumSquares processPrime(unsigned int prime)
{
// same idea as bruteForce() but stop after the first solution was found
for (unsigned int b = 1; b*b < prime; b++)
for (unsigned int a = 1; a < b; a++)
if (a*a + b*b == prime)
return { a, b };
return { 0, 0 }; // never reached
}
// abs isn't available for long long (only smaller int)
template <typename T>
T abs(T a)
{
// actually C++11's std::abs should be able to handle long long values but my compiler fails ... strange !
return a > 0 ? +a : -a;
}
// solve problem: combine each solution of at most index-1 prime with the prime at primes[index]
// return the sum of the smaller primes when finished
unsigned long long search(const std::vector<SumSquares>& solutions = { Seed }, size_t index = 0)
{
// done ?
if (index == primes.size())
{
unsigned long long sum = 0;
// add the smaller squares
for (auto s : solutions)
if (s != Seed)
sum += s.first;
// finally ...
return sum;
}
// combine all previous solutions with the current prime
auto current = primes[index];
std::vector<SumSquares> next;
next.reserve(solutions.size() * 2);
for (auto s : solutions)
{
// https://en.wikipedia.org/wiki/Brahmagupta%E2%80%93Fibonacci_identity
// (ac + bd)^2 + (ad - bc)^2
auto x = s.first * current.first + s.second * current.second;
auto y = abs(s.first * current.second - s.second * current.first);
// ensure that the first number is smaller than the second
if (x > y)
std::swap(x, y);
// found a new representation
next.push_back({ x, y });
// if s is the See then (x,y) is identical in both equations
if (s == Seed)
continue;
// now the same procedure but with swapped signs in the computation of x and y
// (ac - bd)^2 + (ad + bc)^2
x = abs(s.first * current.first - s.second * current.second);
y = s.first * current.second + s.second * current.first;
// ensure that the first number is smaller than the second
if (x > y)
std::swap(x, y);
// found a new representation
next.push_back({ x, y });
}
// without the current prime
auto without = search(solutions, index + 1);
// with the current prime
auto with = search(next, index + 1);
return with + without;
}
int main()
{
unsigned int limit = 150;
std::cin >> limit;
// analyze a single number
//std::cout << bruteForce(65) << std::endl;
// find all relevant primes
for (unsigned int i = 5; i <= limit; i += 4)
if (is4n1Prime(i))
primes.push_back(processPrime(i));
// and here we go !
std::cout << search() << std::endl;
return 0;
}
This solution contains 17 empty lines, 34 comments and 3 preprocessor commands.
Benchmark
The correct solution to the original Project Euler problem was found in 0.12 seconds on an Intel® Core™ i7-2600K CPU @ 3.40GHz.
Peak memory usage was about 3 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
September 14, 2017 submitted solution
September 14, 2017 added comments
Difficulty
Project Euler ranks this problem at 70% (out of 100%).
Links
projecteuler.net/thread=273 - the best forum on the subject (note: you have to submit the correct solution first)
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 | |
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 |
I scored 13,486 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 268 - Counting numbers with at least four distinct ... | Divisibility Multipliers - problem 274 >> |