<< problem 315 - Digital root clocks | Bitwise-OR operations on random integers - problem 323 >> |

# Problem 317: Firecracker

(see projecteuler.net/problem=317)

A firecracker explodes at a height of 100 m above level ground.

It breaks into a large number of very small fragments, which move in every direction;

all of them have the same initial velocity of 20 m/s.

We assume that the fragments move without air resistance, in a uniform gravitational field with g=9.81 m/s^2.

Find the volume (in m^3) of the region through which the fragments move before reaching the ground.

Give your answer rounded to four decimal places.

# My Algorithm

The German Wikipedia page on trajectory (de.wikipedia.org/wiki/Wurfparabel) says that the formula of the hull is:

(1) y = dfrac{v^2}{2g} - dfrac{g x^2}{2v^2} + h_0

where g = 9.81, h_0 = 100 and v = 20

I couldn't find it on the English page (en.wikipedia.org/wiki/Trajectory_of_a_projectile), though.

Splitting the formula into constant and variable parts:

(2) add = dfrac{v^2}{2g} + h_0

(3) factor = dfrac{g}{2v^2}

(4) y = factor * x^2 + add

The volume of a rotated body is

(5) V = pi * integral{(f(x))^2} dx

Unfortunately, equation (5) applies only to rotations around the x-axis.

The fireworks are rotated around the y-axis, thus I have to find its inverse (swap x and y):

(6) x = factor * y^2 + add

(7) factor * y^2 = x - add

(8) y^2 = dfrac{x - add}{factor}

(9) y = sqrt{dfrac{x - add}{factor}}

I replace equation (9) in (5):

(10) V = pi * integral{(sqrt{dfrac{x - add}{factor}})^2} dx

(11) V = pi * integral{dfrac{x - add}{factor}} dx

(12) V = dfrac{pi}{factor} * integral(x - add) dx

Integrating:

(13) integral_x(x - add) dx = dfrac{x^2}{2} - add * x

Only "points above ground" should be taken into consideration:

- the integral starts at zero, x_{low} = 0

- the integral ends at the highest point of any firework, which is in the centre, that means x_{high} = f(0) in (1) which is x_{high} = add

Now all I have to do is computing (12) for both borders x_{low} and x_{high} of the integral:

(14) V = dfrac{pi}{factor} * ((dfrac{x_{high}^2}{2} - add * x_{high}) - (dfrac{x_{low}^2}{2} - add * x_{low})

It turns out that for `x_{low} = 0` most of the equation is zero and simplifies to:

(15) V = dfrac{pi}{factor} * (dfrac{x_{high}^2}{2} - add * x_{high})

x_{high} = add allows even further simplification:

(16) V = dfrac{pi}{factor} * (dfrac{add^2}{2} - add * add)

(17) V = dfrac{pi}{factor} * dfrac{-add^2}{2}

(18) V = -dfrac{pi}{2} * dfrac{add^2}{factor}

Equation 18 is used in my code. And in case you forgot what add and factor are:

(19) V = -dfrac{pi}{2} * dfrac{(dfrac{v^2}{2g} + h_0)^2}{dfrac{g}{2v^2}}

The result is basically found instantly without any memory consumption.

## Alternative Approaches

... I'm a software engineer and felt that something was missing !

Therefore I wrote a simple loop to integrate the initial formula (1) numerically (well, actually I used equation (4) which is the same):

- slowly step along the x-axis and compute `y = factor * x * x + add`

- y will be monotoneously decreasing

- each step that I take adds a small cylinder/slice to the volume (with `sliceHeight = lastY - y`

and `sliceVolume = pi * x * x * sliceHeight`

)

It's tricky to find the correct `step`

which defines the distance between two consecutive x-values:

- if `step`

is too large, then rounding artifacts falsify the result

- if `step`

is too small, then the algorithm can be very slow and the volume because so tiny, that it can't be properly represented by `double`

→ another type of rounding artifacts

My code contains a dynamic adjustment of `step`

after each step, depending on the previous slice volume.

Nevertheless, I can't achieve a sufficient precision: two decimal places are no problem but I haven't found the

optimal value for `averageSliceVolume`

such that the correct result is displayed.

To enable the numeric integration enable `#define NUMERIC_INTEGRATION`

.

# 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>
// nore than enough digits of pi ...

const double pi = 3.141592653589793238462;
// gravition (in m/s^2)

const double g = 9.81;
int main()
{
std::cout << std::fixed << std::setprecision(4);
// velocity in m/s
double velocity = 20;
// height above ground (in m)
double height = 100;
// user can adjust fireworks
std::cin >> velocity >> height;
// split formula into constant summand ...
auto add = velocity * velocity / (2 * g) + height;
// ... and factor
auto factor = - g / (2 * velocity * velocity);
// integral from 0 to "add" of pi * (0.5 * i * i - add * i) / factor
// => it's zero at 0, just compute at "add"
auto result = -0.5 * pi * add * add / factor;
std::cout << result << std::endl;
//#define NUMERIC_INTEGRATION

#ifdef NUMERIC_INTEGRATION
// accumulated volume so far
double volume = 0;
// distance between two consecutive x
double step = 0.00001;
// current x
double x = 0;
// y of previous iteration
double lastY = 0;
// preferred size of a slice, adjust "step" accordingly
double averageSliceVolume = 0.0001;
while (true)
{
// evaluate formula (4)
auto y = x * x * factor + add;
// hit the ground ? ==> done
if (y <= 0)
break;
// height of cylinder
auto sliceHeight = lastY - y;
// volume of cylinder
auto sliceVolume = pi * x * x * sliceHeight;
// add to accumulated volume
volume += sliceVolume;
// slice was too large / too small ? adjust distance to next x
if (sliceVolume > averageSliceVolume)
step /= 2;
else
step *= 2;
// next iteration
x += step;
lastY = y;
}
std::cout << volume << std::endl;
#endif
return 0;
}

This solution contains 16 empty lines, 22 comments and 4 preprocessor commands.

# Interactive test

You can submit your own input to my program and it will be instantly processed at my server:

This is equivalent to`echo "10 0" | ./317`

Output:

*Note:* the original problem's input `20 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)*

# Benchmark

The correct solution to the original Project Euler problem was found in less than 0.01 seconds on a Intel® Core™ i7-2600K CPU @ 3.40GHz.

(compiled for x86_64 / Linux, GCC flags: `-O3 -march=native -fno-exceptions -fno-rtti -std=c++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 5, 2017 submitted solution

July 5, 2017 added comments

# Difficulty

Project Euler ranks this problem at **35%** (out of 100%).

# Links

projecteuler.net/thread=317 - **the** best forum on the subject (*note:* you have to submit the correct solution first)

# Heatmap

green problems solve the original Project Euler problem and have a perfect score of 100% at Hackerrank, too.

yellow problems score less than 100% at Hackerrank (but still solve the original problem).

gray problems are already solved but I haven't published my solution yet.

blue problems are solved and there wasn't a Hackerrank version of it at the time I solved it or I didn't care about it because it differed too much.

red problems are solved but exceed the time limit of one minute or the memory limit of 256 MByte.

*Please click on a problem's number to open my solution to that problem:*

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 |

I scored 13,183 points (out of 15300 possible points, top rank was 17 out of ≈60000 in August 2017) at Hackerrank's Project Euler+.

Look at my progress and performance pages to get more details.

My username at Project Euler is

**stephanbrumme**while it's stbrumme at Hackerrank.

# 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 315 - Digital root clocks | Bitwise-OR operations on random integers - problem 323 >> |