From e36ec10c6ff1f5381732f96ee8626e15c56841a4 Mon Sep 17 00:00:00 2001
From: FrederikBaerentsen <frederik+gitea@baerentsen.net>
Date: Fri, 15 Nov 2024 18:28:48 +0100
Subject: [PATCH] Added 2017/05

---
 2017/05/5.md        | 70 +++++++++++++++++++++++++++++++++++++
 2017/05/solution.py | 85 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 155 insertions(+)
 create mode 100644 2017/05/5.md
 create mode 100644 2017/05/solution.py

diff --git a/2017/05/5.md b/2017/05/5.md
new file mode 100644
index 0000000..1f701aa
--- /dev/null
+++ b/2017/05/5.md
@@ -0,0 +1,70 @@
+## \-\-- Day 5: A Maze of Twisty Trampolines, All Alike \-\--
+
+An urgent
+interrupt arrives
+from the CPU: it\'s trapped in a maze of jump instructions, and it would
+like assistance from any programs with spare cycles to help find the
+exit.
+
+The message includes a list of the offsets for each jump. Jumps are
+relative: `-1` moves to the previous instruction, and `2` skips the next
+one. Start at the first instruction in the list. The goal is to follow
+the jumps until one leads *outside* the list.
+
+In addition, these instructions are a little strange; after each jump,
+the offset of that instruction increases by `1`. So, if you come across
+an offset of `3`, you would move three instructions forward, but change
+it to a `4` for the next time it is encountered.
+
+For example, consider the following list of jump offsets:
+
+    0
+    3
+    0
+    1
+    -3
+
+Positive jumps (\"forward\") move downward; negative jumps move upward.
+For legibility in this example, these offset values will be written all
+on one line, with the current instruction marked in parentheses. The
+following steps would be taken before an exit is found:
+
+-   `(0) 3  0  1  -3 ` - *before* we have taken any steps.
+-   `(1) 3  0  1  -3 ` - jump with offset `0` (that is, don\'t jump at
+    all). Fortunately, the instruction is then incremented to `1`.
+-   ` 2 (3) 0  1  -3 ` - step forward because of the instruction we just
+    modified. The first instruction is incremented again, now to `2`.
+-   ` 2  4  0  1 (-3)` - jump all the way to the end; leave a `4`
+    behind.
+-   ` 2 (4) 0  1  -2 ` - go back to where we just were; increment `-3`
+    to `-2`.
+-   ` 2  5  0  1  -2 ` - jump `4` steps forward, escaping the maze.
+
+In this example, the exit is reached in `5` steps.
+
+*How many steps* does it take to reach the exit?
+
+Your puzzle answer was `381680`.
+
+## \-\-- Part Two \-\-- {#part2}
+
+Now, the jumps are even stranger: after each jump, if the offset was
+*three or more*, instead *decrease* it by `1`. Otherwise, increase it by
+`1` as before.
+
+Using this rule with the above example, the process now takes `10`
+steps, and the offset values after finding the exit are left as
+`2 3 2 3 -1`.
+
+*How many steps* does it now take to reach the exit?
+
+Your puzzle answer was `29717847`.
+
+Both parts of this puzzle are complete! They provide two gold stars:
+\*\*
+
+At this point, you should [return to your Advent calendar](/2017) and
+try another puzzle.
+
+If you still want to see it, you can [get your puzzle
+input](5/input).
diff --git a/2017/05/solution.py b/2017/05/solution.py
new file mode 100644
index 0000000..590dcab
--- /dev/null
+++ b/2017/05/solution.py
@@ -0,0 +1,85 @@
+#!/bin/python3
+import sys
+from pprint import pprint
+
+input_f = sys.argv[1]
+
+
+#########################################
+#                                       #
+#              Part 1                   #
+#                                       #
+#########################################
+
+lines = []
+
+with open(input_f) as file:
+    for line in file:
+        lines.append(int(line.rstrip()))
+
+curr = 0
+tmp = 0
+prev = 0
+steps=0
+while curr <= len(lines)-1:
+    steps+=1
+    #print('Start:',lines)
+    #print('Starting at index',curr,'value',lines[curr]) 
+    prev = curr
+    if curr+lines[curr] > len(lines)-1:
+        break
+    #print('Jumps from [',curr,'] =',lines[curr],'to ',end='')
+    curr = lines[curr]+curr
+    #print('[',curr,'] =',lines[curr])
+
+    #print('Increment',lines[prev],end=' ')
+    lines[prev] += 1
+    #print('to',lines[prev])
+
+    #print('End:',lines,'curr=',curr)    
+    #input()
+print(steps)
+#########################################
+#                                       #
+#              Part 2                   #
+#                                       #
+#########################################
+
+lines = []
+
+with open(input_f) as file:
+    for line in file:
+        lines.append(int(line.rstrip()))
+
+
+curr = 0
+tmp = 0
+prev = 0
+steps=0
+
+while curr <= len(lines)-1:
+    steps+=1
+    #print('Start:',lines)
+    #print('Starting at index',curr,'value',lines[curr]) 
+    prev = curr
+    if curr+lines[curr] > len(lines)-1:
+        break
+    #print('Jumps from [',curr,'] =',lines[curr],'to ',end='')
+    curr = lines[curr]+curr
+    #print('[',curr,'] =',lines[curr])
+    
+    offset = lines[prev] #abs((lines[prev])-(lines[curr]))
+    #print('Offset:',offset)
+    if offset >= 3:
+        #print('Decrease',lines[prev],end=' ')
+        lines[prev] -= 1
+    else:
+        #print('Increase',lines[prev],end=' ')
+        lines[prev] += 1
+    #print('to',lines[prev])
+
+    #print('End:',lines,'curr=',curr)    
+    #input()
+print(steps)
+
+