advent14.ipynb

   1 {
   2  "cells": [
   3   {
   4    "cell_type": "code",
   5    "execution_count": 2,
   6    "metadata": {
   7     "collapsed": false
   8    },
   9    "outputs": [
  10     {
  11      "data": {
  12       "text/plain": [
  13        "[['Vixen',\n",
  14        "  'can',\n",
  15        "  'fly',\n",
  16        "  '8',\n",
  17        "  'km/s',\n",
  18        "  'for',\n",
  19        "  '8',\n",
  20        "  'seconds,',\n",
  21        "  'but',\n",
  22        "  'then',\n",
  23        "  'must',\n",
  24        "  'rest',\n",
  25        "  'for',\n",
  26        "  '53',\n",
  27        "  'seconds.'],\n",
  28        " ['Blitzen',\n",
  29        "  'can',\n",
  30        "  'fly',\n",
  31        "  '13',\n",
  32        "  'km/s',\n",
  33        "  'for',\n",
  34        "  '4',\n",
  35        "  'seconds,',\n",
  36        "  'but',\n",
  37        "  'then',\n",
  38        "  'must',\n",
  39        "  'rest',\n",
  40        "  'for',\n",
  41        "  '49',\n",
  42        "  'seconds.'],\n",
  43        " ['Rudolph',\n",
  44        "  'can',\n",
  45        "  'fly',\n",
  46        "  '20',\n",
  47        "  'km/s',\n",
  48        "  'for',\n",
  49        "  '7',\n",
  50        "  'seconds,',\n",
  51        "  'but',\n",
  52        "  'then',\n",
  53        "  'must',\n",
  54        "  'rest',\n",
  55        "  'for',\n",
  56        "  '132',\n",
  57        "  'seconds.'],\n",
  58        " ['Cupid',\n",
  59        "  'can',\n",
  60        "  'fly',\n",
  61        "  '12',\n",
  62        "  'km/s',\n",
  63        "  'for',\n",
  64        "  '4',\n",
  65        "  'seconds,',\n",
  66        "  'but',\n",
  67        "  'then',\n",
  68        "  'must',\n",
  69        "  'rest',\n",
  70        "  'for',\n",
  71        "  '43',\n",
  72        "  'seconds.'],\n",
  73        " ['Donner',\n",
  74        "  'can',\n",
  75        "  'fly',\n",
  76        "  '9',\n",
  77        "  'km/s',\n",
  78        "  'for',\n",
  79        "  '5',\n",
  80        "  'seconds,',\n",
  81        "  'but',\n",
  82        "  'then',\n",
  83        "  'must',\n",
  84        "  'rest',\n",
  85        "  'for',\n",
  86        "  '38',\n",
  87        "  'seconds.'],\n",
  88        " ['Dasher',\n",
  89        "  'can',\n",
  90        "  'fly',\n",
  91        "  '10',\n",
  92        "  'km/s',\n",
  93        "  'for',\n",
  94        "  '4',\n",
  95        "  'seconds,',\n",
  96        "  'but',\n",
  97        "  'then',\n",
  98        "  'must',\n",
  99        "  'rest',\n",
 100        "  'for',\n",
 101        "  '37',\n",
 102        "  'seconds.'],\n",
 103        " ['Comet',\n",
 104        "  'can',\n",
 105        "  'fly',\n",
 106        "  '3',\n",
 107        "  'km/s',\n",
 108        "  'for',\n",
 109        "  '37',\n",
 110        "  'seconds,',\n",
 111        "  'but',\n",
 112        "  'then',\n",
 113        "  'must',\n",
 114        "  'rest',\n",
 115        "  'for',\n",
 116        "  '76',\n",
 117        "  'seconds.'],\n",
 118        " ['Prancer',\n",
 119        "  'can',\n",
 120        "  'fly',\n",
 121        "  '9',\n",
 122        "  'km/s',\n",
 123        "  'for',\n",
 124        "  '12',\n",
 125        "  'seconds,',\n",
 126        "  'but',\n",
 127        "  'then',\n",
 128        "  'must',\n",
 129        "  'rest',\n",
 130        "  'for',\n",
 131        "  '97',\n",
 132        "  'seconds.'],\n",
 133        " ['Dancer',\n",
 134        "  'can',\n",
 135        "  'fly',\n",
 136        "  '37',\n",
 137        "  'km/s',\n",
 138        "  'for',\n",
 139        "  '1',\n",
 140        "  'seconds,',\n",
 141        "  'but',\n",
 142        "  'then',\n",
 143        "  'must',\n",
 144        "  'rest',\n",
 145        "  'for',\n",
 146        "  '36',\n",
 147        "  'seconds.']]"
 148       ]
 149      },
 150      "execution_count": 2,
 151      "metadata": {},
 152      "output_type": "execute_result"
 153     }
 154    ],
 155    "source": [
 156     "pi14 = [l.strip().split() for l in open('advent14.txt').readlines()]\n",
 157     "pi14"
 158    ]
 159   },
 160   {
 161    "cell_type": "code",
 162    "execution_count": 6,
 163    "metadata": {
 164     "collapsed": false
 165    },
 166    "outputs": [
 167     {
 168      "data": {
 169       "text/plain": [
 170        "[('Vixen', 8, 8, 53),\n",
 171        " ('Blitzen', 13, 4, 49),\n",
 172        " ('Rudolph', 20, 7, 132),\n",
 173        " ('Cupid', 12, 4, 43),\n",
 174        " ('Donner', 9, 5, 38),\n",
 175        " ('Dasher', 10, 4, 37),\n",
 176        " ('Comet', 3, 37, 76),\n",
 177        " ('Prancer', 9, 12, 97),\n",
 178        " ('Dancer', 37, 1, 36)]"
 179       ]
 180      },
 181      "execution_count": 6,
 182      "metadata": {},
 183      "output_type": "execute_result"
 184     }
 185    ],
 186    "source": [
 187     "speeds = [(l[0], int(l[3]), int(l[6]), int(l[13])) for l in pi14]\n",
 188     "speeds"
 189    ]
 190   },
 191   {
 192    "cell_type": "code",
 193    "execution_count": 4,
 194    "metadata": {
 195     "collapsed": true
 196    },
 197    "outputs": [],
 198    "source": [
 199     "import itertools"
 200    ]
 201   },
 202   {
 203    "cell_type": "code",
 204    "execution_count": 23,
 205    "metadata": {
 206     "collapsed": false,
 207     "scrolled": true
 208    },
 209    "outputs": [
 210     {
 211      "data": {
 212       "text/plain": [
 213        "128"
 214       ]
 215      },
 216      "execution_count": 23,
 217      "metadata": {},
 218      "output_type": "execute_result"
 219     }
 220    ],
 221    "source": [
 222     "vixen = itertools.cycle(itertools.chain([speeds[0][1]] * speeds[0][1], [0] * speeds[0][3]))\n",
 223     "v100 = itertools.islice(itertools.accumulate(vixen), 100)\n",
 224     "list(v100)[-1]"
 225    ]
 226   },
 227   {
 228    "cell_type": "code",
 229    "execution_count": 13,
 230    "metadata": {
 231     "collapsed": true
 232    },
 233    "outputs": [],
 234    "source": [
 235     "def nth(iterable, n, default=None):\n",
 236     "        \"Returns the nth item or a default value\"\n",
 237     "        return next(itertools.islice(iterable, n, None), default)"
 238    ]
 239   },
 240   {
 241    "cell_type": "code",
 242    "execution_count": 15,
 243    "metadata": {
 244     "collapsed": false
 245    },
 246    "outputs": [
 247     {
 248      "data": {
 249       "text/plain": [
 250        "128"
 251       ]
 252      },
 253      "execution_count": 15,
 254      "metadata": {},
 255      "output_type": "execute_result"
 256     }
 257    ],
 258    "source": [
 259     "vixen = itertools.accumulate(itertools.cycle(itertools.chain([speeds[0][1]] * speeds[0][1], [0] * speeds[0][3])))\n",
 260     "nth(vixen, 100)"
 261    ]
 262   },
 263   {
 264    "cell_type": "code",
 265    "execution_count": 17,
 266    "metadata": {
 267     "collapsed": false
 268    },
 269    "outputs": [
 270     {
 271      "data": {
 272       "text/plain": [
 273        "1120"
 274       ]
 275      },
 276      "execution_count": 17,
 277      "metadata": {},
 278      "output_type": "execute_result"
 279     }
 280    ],
 281    "source": [
 282     "comet = itertools.accumulate(itertools.cycle(itertools.chain([14] * 10, [0] * 127)))\n",
 283     "nth(comet, 1000)"
 284    ]
 285   },
 286   {
 287    "cell_type": "code",
 288    "execution_count": 18,
 289    "metadata": {
 290     "collapsed": false
 291    },
 292    "outputs": [
 293     {
 294      "data": {
 295       "text/plain": [
 296        "1056"
 297       ]
 298      },
 299      "execution_count": 18,
 300      "metadata": {},
 301      "output_type": "execute_result"
 302     }
 303    ],
 304    "source": [
 305     "dancer = itertools.accumulate(itertools.cycle(itertools.chain([16] * 11, [0] * 162)))\n",
 306     "nth(dancer, 1000)"
 307    ]
 308   },
 309   {
 310    "cell_type": "code",
 311    "execution_count": 55,
 312    "metadata": {
 313     "collapsed": true
 314    },
 315    "outputs": [],
 316    "source": [
 317     "def reindeer_distance(spec):\n",
 318     "    return itertools.accumulate(itertools.cycle(itertools.chain([spec[1]] * spec[2], \n",
 319     "                                                                    [0] * spec[3])))\n",
 320     "\n",
 321     "def reindeer_distance_at_time(spec, time):\n",
 322     "    return nth(reindeer_distance(spec), time-1)"
 323    ]
 324   },
 325   {
 326    "cell_type": "code",
 327    "execution_count": 57,
 328    "metadata": {
 329     "collapsed": false
 330    },
 331    "outputs": [
 332     {
 333      "data": {
 334       "text/plain": [
 335        "[('Vixen', 2640),\n",
 336        " ('Blitzen', 2496),\n",
 337        " ('Rudolph', 2540),\n",
 338        " ('Cupid', 2592),\n",
 339        " ('Donner', 2655),\n",
 340        " ('Dasher', 2460),\n",
 341        " ('Comet', 2493),\n",
 342        " ('Prancer', 2484),\n",
 343        " ('Dancer', 2516)]"
 344       ]
 345      },
 346      "execution_count": 57,
 347      "metadata": {},
 348      "output_type": "execute_result"
 349     }
 350    ],
 351    "source": [
 352     "[(r[0], reindeer_distance_at_time(r, 2503)) for r in speeds]"
 353    ]
 354   },
 355   {
 356    "cell_type": "code",
 357    "execution_count": 58,
 358    "metadata": {
 359     "collapsed": false
 360    },
 361    "outputs": [
 362     {
 363      "data": {
 364       "text/plain": [
 365        "2655"
 366       ]
 367      },
 368      "execution_count": 58,
 369      "metadata": {},
 370      "output_type": "execute_result"
 371     }
 372    ],
 373    "source": [
 374     "max(reindeer_distance_at_time(r, 2501) for r in speeds)"
 375    ]
 376   },
 377   {
 378    "cell_type": "code",
 379    "execution_count": 59,
 380    "metadata": {
 381     "collapsed": false
 382    },
 383    "outputs": [
 384     {
 385      "data": {
 386       "text/plain": [
 387        "[('Vixen', 1.0491803278688525),\n",
 388        " ('Blitzen', 0.9811320754716981),\n",
 389        " ('Rudolph', 1.0071942446043165),\n",
 390        " ('Cupid', 1.0212765957446808),\n",
 391        " ('Donner', 1.0465116279069768),\n",
 392        " ('Dasher', 0.975609756097561),\n",
 393        " ('Comet', 0.9823008849557522),\n",
 394        " ('Prancer', 0.9908256880733946),\n",
 395        " ('Dancer', 1.0)]"
 396       ]
 397      },
 398      "execution_count": 59,
 399      "metadata": {},
 400      "output_type": "execute_result"
 401     }
 402    ],
 403    "source": [
 404     "[(s[0], (s[1] * s[2]) / (s[2] + s[3])) for s in speeds]"
 405    ]
 406   },
 407   {
 408    "cell_type": "code",
 409    "execution_count": 48,
 410    "metadata": {
 411     "collapsed": true
 412    },
 413    "outputs": [],
 414    "source": [
 415     "def rd2(spec, t):\n",
 416     "    return spec[1] * spec[2] * (t // (spec[2] + spec[3])) + spec[1] * min(spec[2], t % (spec[2] + spec[3]))"
 417    ]
 418   },
 419   {
 420    "cell_type": "code",
 421    "execution_count": 49,
 422    "metadata": {
 423     "collapsed": false
 424    },
 425    "outputs": [
 426     {
 427      "data": {
 428       "text/plain": [
 429        "[('Vixen', 2640),\n",
 430        " ('Blitzen', 2496),\n",
 431        " ('Rudolph', 2540),\n",
 432        " ('Cupid', 2592),\n",
 433        " ('Donner', 2655),\n",
 434        " ('Dasher', 2460),\n",
 435        " ('Comet', 2493),\n",
 436        " ('Prancer', 2484),\n",
 437        " ('Dancer', 2516)]"
 438       ]
 439      },
 440      "execution_count": 49,
 441      "metadata": {},
 442      "output_type": "execute_result"
 443     }
 444    ],
 445    "source": [
 446     "[(r[0], rd2(r, 2503)) for r in speeds]"
 447    ]
 448   },
 449   {
 450    "cell_type": "code",
 451    "execution_count": 73,
 452    "metadata": {
 453     "collapsed": false
 454    },
 455    "outputs": [
 456     {
 457      "data": {
 458       "text/plain": [
 459        "[(8, 13, 20, 12, 9, 10, 3, 9, 37),\n",
 460        " (16, 26, 40, 24, 18, 20, 6, 18, 37),\n",
 461        " (24, 39, 60, 36, 27, 30, 9, 27, 37)]"
 462       ]
 463      },
 464      "execution_count": 73,
 465      "metadata": {},
 466      "output_type": "execute_result"
 467     }
 468    ],
 469    "source": [
 470     "list(zip(* (list(itertools.islice(reindeer_distance(r), 3)) for r in speeds)))"
 471    ]
 472   },
 473   {
 474    "cell_type": "code",
 475    "execution_count": 78,
 476    "metadata": {
 477     "collapsed": true
 478    },
 479    "outputs": [],
 480    "source": [
 481     "def score(positions):\n",
 482     "    return [1 if p == max(positions) else 0 for p in positions]"
 483    ]
 484   },
 485   {
 486    "cell_type": "code",
 487    "execution_count": 81,
 488    "metadata": {
 489     "collapsed": false
 490    },
 491    "outputs": [
 492     {
 493      "data": {
 494       "text/plain": [
 495        "[[0, 0, 0, 0, 0, 0, 0, 0, 1],\n",
 496        " [0, 0, 1, 0, 0, 0, 0, 0, 0],\n",
 497        " [0, 0, 1, 0, 0, 0, 0, 0, 0]]"
 498       ]
 499      },
 500      "execution_count": 81,
 501      "metadata": {},
 502      "output_type": "execute_result"
 503     }
 504    ],
 505    "source": [
 506     "list(score(t) for t in zip(* (list(itertools.islice(reindeer_distance(r), 3)) for r in speeds)))"
 507    ]
 508   },
 509   {
 510    "cell_type": "code",
 511    "execution_count": 79,
 512    "metadata": {
 513     "collapsed": false
 514    },
 515    "outputs": [
 516     {
 517      "data": {
 518       "text/plain": [
 519        "[0, 0, 0, 0, 0, 0, 0, 0, 1]"
 520       ]
 521      },
 522      "execution_count": 79,
 523      "metadata": {},
 524      "output_type": "execute_result"
 525     }
 526    ],
 527    "source": [
 528     "score((8, 13, 20, 12, 9, 10, 3, 9, 37))"
 529    ]
 530   },
 531   {
 532    "cell_type": "code",
 533    "execution_count": 85,
 534    "metadata": {
 535     "collapsed": false
 536    },
 537    "outputs": [
 538     {
 539      "data": {
 540       "text/plain": [
 541        "[(0, 0, 0),\n",
 542        " (0, 0, 0),\n",
 543        " (0, 1, 1),\n",
 544        " (0, 0, 0),\n",
 545        " (0, 0, 0),\n",
 546        " (0, 0, 0),\n",
 547        " (0, 0, 0),\n",
 548        " (0, 0, 0),\n",
 549        " (1, 0, 0)]"
 550       ]
 551      },
 552      "execution_count": 85,
 553      "metadata": {},
 554      "output_type": "execute_result"
 555     }
 556    ],
 557    "source": [
 558     "list(zip(* list(score(t) \n",
 559     "                          for t in zip(* (list(itertools.islice(reindeer_distance(r), 3)) \n",
 560     "                                          for r in speeds)))))"
 561    ]
 562   },
 563   {
 564    "cell_type": "code",
 565    "execution_count": 84,
 566    "metadata": {
 567     "collapsed": false
 568    },
 569    "outputs": [
 570     {
 571      "data": {
 572       "text/plain": [
 573        "[0, 0, 2, 0, 0, 0, 0, 0, 1]"
 574       ]
 575      },
 576      "execution_count": 84,
 577      "metadata": {},
 578      "output_type": "execute_result"
 579     }
 580    ],
 581    "source": [
 582     "list(sum(ps) \n",
 583     "     for ps in zip(* list(score(t) \n",
 584     "                          for t in zip(* (list(itertools.islice(reindeer_distance(r), 3)) \n",
 585     "                                          for r in speeds)))))"
 586    ]
 587   },
 588   {
 589    "cell_type": "code",
 590    "execution_count": 86,
 591    "metadata": {
 592     "collapsed": false
 593    },
 594    "outputs": [
 595     {
 596      "data": {
 597       "text/plain": [
 598        "[1059, 5, 887, 13, 414, 0, 22, 153, 1]"
 599       ]
 600      },
 601      "execution_count": 86,
 602      "metadata": {},
 603      "output_type": "execute_result"
 604     }
 605    ],
 606    "source": [
 607     "list(sum(ps) \n",
 608     "     for ps in zip(* list(score(t) \n",
 609     "                          for t in zip(* (list(itertools.islice(reindeer_distance(r), 2503)) \n",
 610     "                                          for r in speeds)))))"
 611    ]
 612   },
 613   {
 614    "cell_type": "code",
 615    "execution_count": 87,
 616    "metadata": {
 617     "collapsed": false
 618    },
 619    "outputs": [
 620     {
 621      "data": {
 622       "text/plain": [
 623        "1059"
 624       ]
 625      },
 626      "execution_count": 87,
 627      "metadata": {},
 628      "output_type": "execute_result"
 629     }
 630    ],
 631    "source": [
 632     "max(list(sum(ps) \n",
 633     "     for ps in zip(* list(score(t) \n",
 634     "                          for t in zip(* (list(itertools.islice(reindeer_distance(r), 2503)) \n",
 635     "                                          for r in speeds))))))"
 636    ]
 637   },
 638   {
 639    "cell_type": "code",
 640    "execution_count": null,
 641    "metadata": {
 642     "collapsed": true
 643    },
 644    "outputs": [],
 645    "source": []
 646   }
 647  ],
 648  "metadata": {
 649   "kernelspec": {
 650    "display_name": "Python 3",
 651    "language": "python",
 652    "name": "python3"
 653   },
 654   "language_info": {
 655    "codemirror_mode": {
 656     "name": "ipython",
 657     "version": 3
 658    },
 659    "file_extension": ".py",
 660    "mimetype": "text/x-python",
 661    "name": "python",
 662    "nbconvert_exporter": "python",
 663    "pygments_lexer": "ipython3",
 664    "version": "3.4.3"
 665   }
 666  },
 667  "nbformat": 4,
 668  "nbformat_minor": 0
 669 }