Did problem 11 in ipython.

ipython/EulerProblem001.ipynb

@@ -81,7 +81,7 @@
    "version": "3.5.4"
   },
   "tags": [
-   "brute_force"
+   "brute force"
   ]
  },
  "nbformat": 4,

ipython/EulerProblem010.html

@@ -183,7 +183,179 @@ div#notebook {
 </div>
 <div class="inner_cell">
 <div class="text_cell_render border-box-sizing rendered_html">
-<h1 id="Euler-Problem-10">Euler Problem 10<a class="anchor-link" href="#Euler-Problem-10">&#182;</a></h1>
+<h1 id="Euler-Problem-10">Euler Problem 10<a class="anchor-link" href="#Euler-Problem-10">&#182;</a></h1><p>The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.</p>
+<p>Find the sum of all the primes below two million.</p>
+
+</div>
+</div>
+</div>
+<div class="cell border-box-sizing text_cell rendered">
+<div class="prompt input_prompt">
+</div>
+<div class="inner_cell">
+<div class="text_cell_render border-box-sizing rendered_html">
+<p>Okay, reuse prime generator from 7 and go.</p>
+
+</div>
+</div>
+</div>
+<div class="cell border-box-sizing code_cell rendered">
+<div class="input">
+<div class="prompt input_prompt">In&nbsp;[1]:</div>
+<div class="inner_cell">
+    <div class="input_area">
+<div class=" highlight hl-ipython3"><pre><span></span><span class="kn">import</span> <span class="nn">timeit</span>
+
+<span class="k">def</span> <span class="nf">is_prime</span><span class="p">(</span><span class="n">n</span><span class="p">,</span> <span class="n">smaller_primes</span><span class="p">):</span>
+    <span class="k">for</span> <span class="n">s</span> <span class="ow">in</span> <span class="n">smaller_primes</span><span class="p">:</span>
+        <span class="k">if</span> <span class="n">n</span> <span class="o">%</span> <span class="n">s</span> <span class="o">==</span> <span class="mi">0</span><span class="p">:</span>
+            <span class="k">return</span> <span class="kc">False</span>
+        <span class="k">if</span> <span class="n">s</span> <span class="o">*</span> <span class="n">s</span> <span class="o">&gt;</span> <span class="n">n</span><span class="p">:</span>
+            <span class="k">return</span> <span class="kc">True</span>
+    <span class="k">return</span> <span class="kc">True</span>
+
+<span class="k">def</span> <span class="nf">prime_generator_function</span><span class="p">():</span>
+    <span class="n">primes</span> <span class="o">=</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">7</span><span class="p">]</span>
+    <span class="k">for</span> <span class="n">p</span> <span class="ow">in</span> <span class="n">primes</span><span class="p">:</span>
+        <span class="k">yield</span> <span class="n">p</span>
+    <span class="k">while</span> <span class="kc">True</span><span class="p">:</span>
+        <span class="n">p</span> <span class="o">+=</span> <span class="mi">2</span>
+        <span class="k">if</span> <span class="n">is_prime</span><span class="p">(</span><span class="n">p</span><span class="p">,</span> <span class="n">primes</span><span class="p">):</span>
+            <span class="n">primes</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
+            <span class="k">yield</span> <span class="n">p</span>
+    
+<span class="k">def</span> <span class="nf">brute_force</span><span class="p">():</span> 
+    <span class="n">ps</span> <span class="o">=</span> <span class="n">prime_generator_function</span><span class="p">()</span>
+    <span class="n">s</span> <span class="o">=</span> <span class="mi">0</span>
+    <span class="n">p</span> <span class="o">=</span> <span class="nb">next</span><span class="p">(</span><span class="n">ps</span><span class="p">)</span>
+    <span class="k">while</span> <span class="n">p</span> <span class="o">&lt;</span> <span class="mi">2000000</span><span class="p">:</span>
+        <span class="n">s</span> <span class="o">+=</span> <span class="n">p</span>
+        <span class="n">p</span> <span class="o">=</span> <span class="nb">next</span><span class="p">(</span><span class="n">ps</span><span class="p">)</span>
+    <span class="k">return</span> <span class="n">s</span>
+    
+<span class="nb">print</span><span class="p">(</span><span class="n">timeit</span><span class="o">.</span><span class="n">timeit</span><span class="p">(</span><span class="n">brute_force</span><span class="p">,</span> <span class="n">number</span><span class="o">=</span><span class="mi">10</span><span class="p">))</span>
+<span class="k">assert</span><span class="p">(</span><span class="n">brute_force</span><span class="p">()</span> <span class="o">==</span> <span class="mi">142913828922</span><span class="p">)</span>
+<span class="nb">print</span><span class="p">(</span><span class="n">brute_force</span><span class="p">())</span>
+</pre></div>
+
+</div>
+</div>
+</div>
+
+<div class="output_wrapper">
+<div class="output">
+
+
+<div class="output_area"><div class="prompt"></div>
+<div class="output_subarea output_stream output_stdout output_text">
+<pre>61.8695481220002
+142913828922
+</pre>
+</div>
+</div>
+
+</div>
+</div>
+
+</div>
+<div class="cell border-box-sizing text_cell rendered">
+<div class="prompt input_prompt">
+</div>
+<div class="inner_cell">
+<div class="text_cell_render border-box-sizing rendered_html">
+<p>Okay, here it may actually be way smarter to use a sieve. We implent it because the old one was shitty. Okay, I am actually interested in the time difference. So we use the old one first and then implement the optimization.</p>
+
+</div>
+</div>
+</div>
+<div class="cell border-box-sizing code_cell rendered">
+<div class="input">
+<div class="prompt input_prompt">In&nbsp;[2]:</div>
+<div class="inner_cell">
+    <div class="input_area">
+<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">get_primes_smaller</span><span class="p">(</span><span class="n">number</span><span class="p">):</span>
+    <span class="n">primes</span> <span class="o">=</span> <span class="p">[]</span>
+    <span class="n">prospects</span> <span class="o">=</span> <span class="p">[</span><span class="n">n</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="n">number</span><span class="p">)]</span>
+    <span class="k">while</span> <span class="n">prospects</span><span class="p">:</span>
+        <span class="n">p</span> <span class="o">=</span> <span class="n">prospects</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
+        <span class="n">prospects</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">prospects</span> <span class="k">if</span> <span class="n">x</span> <span class="o">%</span> <span class="n">p</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">]</span>
+        <span class="n">primes</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
+    <span class="k">return</span> <span class="n">primes</span>
+
+<span class="k">def</span> <span class="nf">brute_force</span><span class="p">():</span>
+    <span class="k">return</span> <span class="nb">sum</span><span class="p">(</span><span class="n">get_primes_smaller</span><span class="p">(</span><span class="mi">2000000</span><span class="p">))</span>
+
+<span class="c1">#print(timeit.timeit(brute_force, number=1))</span>
+<span class="c1">#print(brute_force())</span>
+</pre></div>
+
+</div>
+</div>
+</div>
+
+</div>
+<div class="cell border-box-sizing text_cell rendered">
+<div class="prompt input_prompt">
+</div>
+<div class="inner_cell">
+<div class="text_cell_render border-box-sizing rendered_html">
+<p>This did not even terminate. We optimize the sieve by stopping when $p^2 > number$.</p>
+
+</div>
+</div>
+</div>
+<div class="cell border-box-sizing code_cell rendered">
+<div class="input">
+<div class="prompt input_prompt">In&nbsp;[3]:</div>
+<div class="inner_cell">
+    <div class="input_area">
+<div class=" highlight hl-ipython3"><pre><span></span><span class="k">def</span> <span class="nf">sieve_of_eratosthenes</span><span class="p">(</span><span class="n">number</span><span class="p">):</span>
+    <span class="n">primes</span> <span class="o">=</span> <span class="p">[]</span>
+    <span class="n">prospects</span> <span class="o">=</span> <span class="p">[</span><span class="n">n</span> <span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">2</span><span class="p">,</span> <span class="n">number</span><span class="p">)]</span>
+    <span class="k">while</span> <span class="n">prospects</span><span class="p">:</span>
+        <span class="n">p</span> <span class="o">=</span> <span class="n">prospects</span><span class="p">[</span><span class="mi">0</span><span class="p">]</span>
+        <span class="n">prospects</span> <span class="o">=</span> <span class="p">[</span><span class="n">x</span> <span class="k">for</span> <span class="n">x</span> <span class="ow">in</span> <span class="n">prospects</span> <span class="k">if</span> <span class="n">x</span> <span class="o">%</span> <span class="n">p</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">]</span>
+        <span class="n">primes</span><span class="o">.</span><span class="n">append</span><span class="p">(</span><span class="n">p</span><span class="p">)</span>
+        <span class="k">if</span> <span class="n">p</span> <span class="o">*</span> <span class="n">p</span> <span class="o">&gt;</span> <span class="n">number</span><span class="p">:</span>
+            <span class="k">break</span>
+    <span class="k">return</span> <span class="n">primes</span> <span class="o">+</span> <span class="n">prospects</span>
+
+<span class="k">def</span> <span class="nf">brute_force</span><span class="p">():</span>
+    <span class="k">return</span> <span class="nb">sum</span><span class="p">(</span><span class="n">sieve_of_eratosthenes</span><span class="p">(</span><span class="mi">2000000</span><span class="p">))</span>
+
+<span class="k">assert</span><span class="p">(</span><span class="n">sieve_of_eratosthenes</span><span class="p">(</span><span class="mi">10</span><span class="p">)</span> <span class="o">==</span> <span class="p">[</span><span class="mi">2</span><span class="p">,</span> <span class="mi">3</span><span class="p">,</span> <span class="mi">5</span><span class="p">,</span> <span class="mi">7</span><span class="p">,])</span>
+<span class="nb">print</span><span class="p">(</span><span class="n">timeit</span><span class="o">.</span><span class="n">timeit</span><span class="p">(</span><span class="n">brute_force</span><span class="p">,</span> <span class="n">number</span><span class="o">=</span><span class="mi">10</span><span class="p">))</span>
+<span class="k">assert</span><span class="p">(</span><span class="n">brute_force</span><span class="p">()</span> <span class="o">==</span> <span class="mi">142913828922</span><span class="p">)</span>
+<span class="nb">print</span><span class="p">(</span><span class="n">brute_force</span><span class="p">())</span>
+</pre></div>
+
+</div>
+</div>
+</div>
+
+<div class="output_wrapper">
+<div class="output">
+
+
+<div class="output_area"><div class="prompt"></div>
+<div class="output_subarea output_stream output_stdout output_text">
+<pre>74.5315607270004
+142913828922
+</pre>
+</div>
+</div>
+
+</div>
+</div>
+
+</div>
+<div class="cell border-box-sizing text_cell rendered">
+<div class="prompt input_prompt">
+</div>
+<div class="inner_cell">
+<div class="text_cell_render border-box-sizing rendered_html">
+<p>Okay, I honestly did not expect this to be slower than our generator. Gotta keep that in mind for future prime related problems.</p>
+
 </div>
 </div>
 </div>

ipython/EulerProblem010.ipynb

@@ -5,7 +5,150 @@
    "metadata": {},
    "source": [
     "# Euler Problem 10\n",
-    "\n"
+    "\n",
+    "The sum of the primes below 10 is 2 + 3 + 5 + 7 = 17.\n",
+    "\n",
+    "Find the sum of all the primes below two million."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Okay, reuse prime generator from 7 and go."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "61.8695481220002\n",
+      "142913828922\n"
+     ]
+    }
+   ],
+   "source": [
+    "import timeit\n",
+    "\n",
+    "def is_prime(n, smaller_primes):\n",
+    "    for s in smaller_primes:\n",
+    "        if n % s == 0:\n",
+    "            return False\n",
+    "        if s * s > n:\n",
+    "            return True\n",
+    "    return True\n",
+    "\n",
+    "def prime_generator_function():\n",
+    "    primes = [2, 3, 5, 7]\n",
+    "    for p in primes:\n",
+    "        yield p\n",
+    "    while True:\n",
+    "        p += 2\n",
+    "        if is_prime(p, primes):\n",
+    "            primes.append(p)\n",
+    "            yield p\n",
+    "    \n",
+    "def brute_force(): \n",
+    "    ps = prime_generator_function()\n",
+    "    s = 0\n",
+    "    p = next(ps)\n",
+    "    while p < 2000000:\n",
+    "        s += p\n",
+    "        p = next(ps)\n",
+    "    return s\n",
+    "    \n",
+    "print(timeit.timeit(brute_force, number=10))\n",
+    "assert(brute_force() == 142913828922)\n",
+    "print(brute_force())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Okay, here it may actually be way smarter to use a sieve. We implent it because the old one was shitty. Okay, I am actually interested in the time difference. So we use the old one first and then implement the optimization."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "def get_primes_smaller(number):\n",
+    "    primes = []\n",
+    "    prospects = [n for n in range(2, number)]\n",
+    "    while prospects:\n",
+    "        p = prospects[0]\n",
+    "        prospects = [x for x in prospects if x % p != 0]\n",
+    "        primes.append(p)\n",
+    "    return primes\n",
+    "\n",
+    "def brute_force():\n",
+    "    return sum(get_primes_smaller(2000000))\n",
+    "\n",
+    "#print(timeit.timeit(brute_force, number=1))\n",
+    "#print(brute_force())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "This did not even terminate. We optimize the sieve by stopping when $p^2 > number$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "74.5315607270004\n",
+      "142913828922\n"
+     ]
+    }
+   ],
+   "source": [
+    "def sieve_of_eratosthenes(number):\n",
+    "    primes = []\n",
+    "    prospects = [n for n in range(2, number)]\n",
+    "    while prospects:\n",
+    "        p = prospects[0]\n",
+    "        prospects = [x for x in prospects if x % p != 0]\n",
+    "        primes.append(p)\n",
+    "        if p * p > number:\n",
+    "            break\n",
+    "    return primes + prospects\n",
+    "\n",
+    "def brute_force():\n",
+    "    return sum(sieve_of_eratosthenes(2000000))\n",
+    "\n",
+    "assert(sieve_of_eratosthenes(10) == [2, 3, 5, 7,])\n",
+    "print(timeit.timeit(brute_force, number=10))\n",
+    "assert(brute_force() == 142913828922)\n",
+    "print(brute_force())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Okay, I honestly did not expect this to be slower than our generator. Gotta keep that in mind for future prime related problems."
    ]
   }
  ],
@@ -29,7 +172,9 @@
    "version": "3.5.4"
   },
   "tags": [
-   "primes"
+   "primes",
+   "brute force",
+   "timeit"
   ]
  },
  "nbformat": 4,

ipython/EulerProblem011.ipynb

@@ -0,0 +1,187 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Euler Problem 11\n",
+    "\n",
+    "In the 20×20 grid below, four numbers along a diagonal line have been marked in red.\n",
+    "\n",
+    "~~~\n",
+    "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08\n",
+    "49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00\n",
+    "81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65\n",
+    "52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91\n",
+    "22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80\n",
+    "24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50\n",
+    "32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70\n",
+    "67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21\n",
+    "24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72\n",
+    "21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95\n",
+    "78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92\n",
+    "16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57\n",
+    "86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58\n",
+    "19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40\n",
+    "04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66\n",
+    "88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69\n",
+    "04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36\n",
+    "20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16\n",
+    "20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54\n",
+    "01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48\n",
+    "~~~\n",
+    "\n",
+    "The product of these numbers is $26 × 63 × 78 × 14 = 1788696$.\n",
+    "\n",
+    "What is the greatest product of four adjacent numbers in the same direction (up, down, left, right, or diagonally) in the 20×20 grid?"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We start by parsing the array into three lists of lists (horizontal, diagonal, vertical).\n",
+    "\n",
+    "97, 17, 79, 11, 89, 44, 38, 94, 78, 0, 62, 54, 58, 4, 27, 53, 36, 1, 1, 1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {
+    "collapsed": false,
+    "scrolled": true
+   },
+   "outputs": [],
+   "source": [
+    "s = \"\"\"\n",
+    "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08\n",
+    "49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00\n",
+    "81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65\n",
+    "52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91\n",
+    "22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80\n",
+    "24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50\n",
+    "32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70\n",
+    "67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21\n",
+    "24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72\n",
+    "21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95\n",
+    "78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92\n",
+    "16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57\n",
+    "86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58\n",
+    "19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40\n",
+    "04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66\n",
+    "88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69\n",
+    "04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36\n",
+    "20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16\n",
+    "20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54\n",
+    "01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48\n",
+    "\"\"\"\n",
+    "\n",
+    "def get_index(xs, index, default):\n",
+    "    if index < 0:\n",
+    "        return default\n",
+    "    try:\n",
+    "        return xs[index]\n",
+    "    except IndexError:\n",
+    "        return default\n",
+    "\n",
+    "hss = [list(map(int, h.split())) for h in s.split('\\n') if h]\n",
+    "vss = [list(vs) for vs in zip(*hss)]\n",
+    "# diagonal from top left to bottom right\n",
+    "dss = [[get_index(hs, -19 + i + j, 1) for j, hs in enumerate(hss)] for i in range(39)]\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "I really love the way we retrieve the vertical list. (We need the ugly conversion to list because otherwise we cannot concatenate them.) It is at the limit of my mental capabilities to understand why this works. But actually it is quite straight forward. If we provide two lists, zip creates a two-tuple for each field in the lists. If we provide n lists, zip creates a n-tuple for each field in the lists. Easy.\n",
+    "\n",
+    "Now we create big list of lists and search each one for the greates four product and then get the maximum. Straight forward. We borrow the find product function from problem 8 because I like it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "xss = hss + vss + dss\n",
+    "\n",
+    "def product(xs):\n",
+    "    from operator import mul\n",
+    "    from functools import reduce\n",
+    "    return reduce(mul, xs, 1)\n",
+    "\n",
+    "def get_largest_product_of_n_digits(xs, n):\n",
+    "    return max([product(xs[i:i + n]) for i in range(len(xs))])\n",
+    "\n",
+    "s = max([get_largest_product_of_n_digits(xs, 4) for xs in xss])\n",
+    "assert(s != 70600674)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Okay, I am actually really dumb. I forgot about the other diagonal. I think I have made the same mistake back when I solved this for the first time. So let's get the missing dss and get the solution."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "70600674\n"
+     ]
+    }
+   ],
+   "source": [
+    "# diagonal from bottom left to top right\n",
+    "hss.reverse()\n",
+    "dss = [[get_index(hs, -19 + i + j, 1) for j, hs in enumerate(hss)] for i in range(39)]\n",
+    "\n",
+    "s = max([get_largest_product_of_n_digits(ds, 4) for ds in dss])\n",
+    "assert(s == 70600674)\n",
+    "print(s)"
+   ]
+  }
+ ],
+ "metadata": {
+  "completion_date": "Sun, 31 Aug 2014, 07:39",
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.5.4"
+  },
+  "tags": [
+   "brute force",
+   "product",
+   "matrix",
+   "tricky",
+   "diagonal"
+  ]
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

ipython/EulerProblem012.ipynb

@@ -0,0 +1,66 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Euler Problem 12\n",
+    "\n",
+    "The sequence of triangle numbers is generated by adding the natural numbers. So the 7th triangle number would be $1 + 2 + 3 + 4 + 5 + 6 + 7 = 28$. The first ten terms would be:\n",
+    "\n",
+    "$1, 3, 6, 10, 15, 21, 28, 36, 45, 55, \\dots$\n",
+    "\n",
+    "Let us list the factors of the first seven triangle numbers:\n",
+    "\n",
+    "~~~\n",
+    " 1: 1\n",
+    " 3: 1,3\n",
+    " 6: 1,2,3,6\n",
+    "10: 1,2,5,10\n",
+    "15: 1,3,5,15\n",
+    "21: 1,3,7,21\n",
+    "28: 1,2,4,7,14,28\n",
+    "~~~\n",
+    "\n",
+    "We can see that 28 is the first triangle number to have over five divisors.\n",
+    "\n",
+    "What is the value of the first triangle number to have over five hundred divisors?"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "completion_date": "Sun, 31 Aug 2014, 17:07",
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.5.4"
+  },
+  "tags": [
+   "triangular",
+   "number"
+  ]
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}

ipython/template.html

@@ -31,7 +31,7 @@
               <thead>
                 <tr>
                   <th scope="col">Name</th>
-                  <th scope="col">Complete on</th>
+                  <th scope="col">Completion date</th>
                   <th scope="col">Link</th>
                   <th scope="col">Tags</th>
                 </tr>