diff --git a/2017/03/3.md b/2017/03/3.md
new file mode 100644
index 0000000..97fcf45
--- /dev/null
+++ b/2017/03/3.md
@@ -0,0 +1,73 @@
+## \-\-- Day 3: Spiral Memory \-\--
+
+You come across an experimental new kind of memory stored on an
+[infinite two-dimensional
+grid]{title="Good thing we have all these infinite two-dimensional grids lying around!"}.
+
+Each square on the grid is allocated in a spiral pattern starting at a
+location marked `1` and then counting up while spiraling outward. For
+example, the first few squares are allocated like this:
+
+    17  16  15  14  13
+    18   5   4   3  12
+    19   6   1   2  11
+    20   7   8   9  10
+    21  22  23---> ...
+
+While this is very space-efficient (no squares are skipped), requested
+data must be carried back to square `1` (the location of the only access
+port for this memory system) by programs that can only move up, down,
+left, or right. They always take the shortest path: the [Manhattan
+Distance](https://en.wikipedia.org/wiki/Taxicab_geometry) between the
+location of the data and square `1`.
+
+For example:
+
+-   Data from square `1` is carried `0` steps, since it\'s at the access
+    port.
+-   Data from square `12` is carried `3` steps, such as: down, left,
+    left.
+-   Data from square `23` is carried only `2` steps: up twice.
+-   Data from square `1024` must be carried `31` steps.
+
+*How many steps* are required to carry the data from the square
+identified in your puzzle input all the way to the access port?
+
+Your puzzle answer was `371`.
+
+The first half of this puzzle is complete! It provides one gold star: \*
+
+## \-\-- Part Two \-\-- {#part2}
+
+As a stress test on the system, the programs here clear the grid and
+then store the value `1` in square `1`. Then, in the same allocation
+order as shown above, they store the sum of the values in all adjacent
+squares, including diagonals.
+
+So, the first few squares\' values are chosen as follows:
+
+-   Square `1` starts with the value `1`.
+-   Square `2` has only one adjacent filled square (with value `1`), so
+    it also stores `1`.
+-   Square `3` has both of the above squares as neighbors and stores the
+    sum of their values, `2`.
+-   Square `4` has all three of the aforementioned squares as neighbors
+    and stores the sum of their values, `4`.
+-   Square `5` only has the first and fourth squares as neighbors, so it
+    gets the value `5`.
+
+Once a square is written, its value does not change. Therefore, the
+first few squares would receive the following values:
+
+    147  142  133  122   59
+    304    5    4    2   57
+    330   10    1    1   54
+    351   11   23   25   26
+    362  747  806--->   ...
+
+What is the *first value written* that is *larger* than your puzzle
+input?
+
+Answer:
+
+Your puzzle input is still `368078`{.puzzle-input}.
diff --git a/2017/03/solution.py b/2017/03/solution.py
new file mode 100644
index 0000000..658cebd
--- /dev/null
+++ b/2017/03/solution.py
@@ -0,0 +1,56 @@
+#!/bin/python3
+import sys
+from pprint import pprint
+import numpy as np
+import math
+
+def manhattan_distance(a, b):
+        return np.abs(a - b).sum()
+
+def spiral_ccw(A):
+    A = np.array(A)
+    out = []
+    while(A.size):
+        out.append(A[0][::-1])    # first row reversed
+        A = A[1:][::-1].T         # cut off first row and rotate clockwise
+    return np.concatenate(out)
+
+def base_spiral(nrow, ncol):
+    return spiral_ccw(np.arange(nrow*ncol).reshape(nrow,ncol))[::-1]
+
+def to_spiral(A):
+    A = np.array(A)
+    B = np.empty_like(A)
+    B.flat[base_spiral(*A.shape)] = A.flat
+    return B
+
+input_f = sys.argv[1]
+
+#########################################
+#                                       #
+#              Part 1                   #
+#                                       #
+#########################################
+
+number = int(input_f)
+org = number
+while not math.sqrt(number).is_integer():
+    number+=1
+
+mid = int((math.sqrt(number)-1)/2)
+
+length = int(math.sqrt(number))
+
+a = [mid, mid]
+
+arr = to_spiral(np.arange(1,number+1).reshape(length,length))
+
+b = np.where(arr == org)
+
+print(manhattan_distance(np.array(a),np.array([b[0][0],b[1][0]])))
+
+#########################################
+#                                       #
+#              Part 2                   #
+#                                       #
+#########################################
diff --git a/2017/03/test2 b/2017/03/test2
new file mode 100644
index 0000000..7ceb017
--- /dev/null
+++ b/2017/03/test2
@@ -0,0 +1,7 @@
+37 36 35 34 33 32 31
+38 17 16 15 14 13 30
+39 18 05 04 03 12 29
+40 19 06 01 02 11 28
+41 20 07 08 09 10 27
+42 21 22 23 24 25 26
+43 44 45 46 47 48 49 
diff --git a/2017/03/test3 b/2017/03/test3
new file mode 100644
index 0000000..2988100
--- /dev/null
+++ b/2017/03/test3
@@ -0,0 +1,9 @@
+65 64 63 62 61 60 59 58 57
+66 37 36 35 34 33 32 31 56
+67 38 17 16 15 14 13 30 55
+68 39 18 05 04 03 12 29 54
+69 40 19 06 01 02 11 28 53
+70 41 20 07 08 09 10 27 52
+71 42 21 22 23 24 25 26 51
+72 43 44 45 46 47 48 49 50 
+73 74 75 76 77 78 79 80 81