Added 2019 day 13 part 1

2019/13/README.md

@@ -0,0 +1,34 @@
+# 2019 Day 13: Care Package
+Copyright (c) Eric Wastl
+#### [Direct Link](https://adventofcode.com/2019/day/13)
+
+## Part 1
+As you ponder the solitude of space and the ever-increasing three-hour roundtrip for messages between you and Earth, you notice that the Space Mail Indicator Light is blinking. To help keep you sane, the Elves have sent you a care package.
+
+It's a new game for the ship's [arcade cabinet](https://en.wikipedia.org/wiki/Arcade_cabinet)! Unfortunately, the arcade is **all the way** on the other end of the ship. Surely, it won't be hard to build your own - the care package even comes with schematics.
+
+The arcade cabinet runs [Intcode](https://adventofcode.com/2019/day/9) software like the game the Elves sent (your puzzle input). It has a primitive screen capable of drawing square tiles on a grid. The software draws tiles to the screen with output instructions: every three output instructions specify the `x` position (distance from the left), `y` position (distance from the top), and `tile id`. The `tile id` is interpreted as follows:
+
+- `0` is an **empty** tile. No game object appears in this tile.
+- `1` is a **wall** tile. Walls are indestructible barriers.
+- `2` is a **block** tile. Blocks can be broken by the ball.
+- `3` is a **horizontal paddle** tile. The paddle is indestructible.
+- `4` is a **ball** tile. The ball moves diagonally and bounces off objects.
+
+For example, a sequence of output values like `1,2,3,6,5,4` would draw a **horizontal paddle** tile (`1` tile from the left and `2` tiles from the top) and a **ball** tile (`6` tiles from the left and `5` tiles from the top).
+
+Start the game. **How many block tiles are on the screen when the game exits**?
+
+## Part 2
+
+The game didn't run because you didn't put in any quarters. Unfortunately, you did not bring any quarters. Memory address `0` represents the number of quarters that have been inserted; set it to `2` to play for free.
+
+The arcade cabinet has a [joystick](https://en.wikipedia.org/wiki/Joystick) that can move left and right. The software reads the position of the joystick with input instructions:
+
+- If the joystick is in the **neutral position**, provide `0`.
+- If the joystick is **tilted to the left**, provide `-1`.
+- If the joystick is **tilted to the right**, provide `1`.
+
+The arcade cabinet also has a [segment display](https://en.wikipedia.org/wiki/Display_device#Segment_displays) capable of showing a single number that represents the player's current score. When three output instructions specify `X=-1, Y=0`, the third output instruction is not a tile; the value instead specifies the new score to show in the segment display. For example, a sequence of output values like `-1,0,12345` would show `12345` as the player's current score.
+
+Beat the game by breaking all the blocks. **What is your score after the last block is broken**?

2019/13/code.py

@@ -0,0 +1,110 @@
+""" https://adventofcode.com/2019/day/13 """
+
+class InvalidOpcode(Exception):
+    pass
+
+class mylist(list):
+    def __getitem__(self, item):
+        try:
+            return super(mylist,self).__getitem__(item)
+        except IndexError as e:
+            if item < 0: raise IndexError()
+            super(mylist,self).extend([0]*(item + 1 - super(mylist,self).__len__()))
+            return super(mylist,self).__getitem__(item)
+
+    def __setitem__(self, idx, val):
+        try:
+            return super(mylist,self).__setitem__(idx,val)
+        except IndexError as e:
+            if idx < 0: raise IndexError()
+            super(mylist,self).extend([0]*(idx + 1 - super(mylist,self).__len__()))
+            return super(mylist,self).__setitem__(idx,val)
+
+def readFile():
+    with open(f"{__file__.rstrip('code.py')}input.txt", "r") as f:
+        return [int(num) for num in f.readline().split(",")]
+
+def getOutput(vals : list, input=0, base=0):
+    vals = mylist(vals)
+    i = 0
+    out = []
+    while 1:
+        opcode = (vals[i] % 100,
+            vals[i] // 100 % 10,
+            vals[i] // 1000 % 10,
+            vals[i] // 10000 % 10)
+
+        # 0 Parameter
+        if opcode[0] in [99]: # Termination
+            return vals, out
+        
+        # 1 Parameter
+        elif opcode[0] in [3,4,9]:
+            a = vals[i+1] if not opcode[1] else i+1 if opcode[1] == 1 else base+vals[i+1]
+            if opcode[0] == 3: # Input
+                vals[a] = input
+            elif opcode[0] == 4: # Output
+                vals[0] = vals[a]
+                out.append(vals[0])
+            elif opcode[0] == 9: # Adjust Base
+                base += vals[a]
+            i += 2
+
+        # 2 Parameter
+        elif opcode[0] in [5,6]:
+            a = vals[i+1] if not opcode[1] else i+1 if opcode[1] == 1 else base+vals[i+1]
+            b = vals[i+2] if not opcode[2] else i+2 if opcode[2] == 1 else base+vals[i+2]
+            if opcode[0] == 5 and vals[a] != 0: # Jump-if-true
+                i = vals[b]
+            elif opcode[0] == 6 and vals[a] == 0: # Jump-if-false
+                i = vals[b]
+            else:
+                i += 3
+        
+        # 3 Parameter
+        elif opcode[0] in [1,2,7,8]:
+            a = vals[i+1] if not opcode[1] else i+1 if opcode[1] == 1 else base+vals[i+1]
+            b = vals[i+2] if not opcode[2] else i+2 if opcode[2] == 1 else base+vals[i+2]
+            c = vals[i+3] if not opcode[3] else i+3 if opcode[3] == 1 else base+vals[i+3]
+            if opcode[0] == 1: # Addition
+                vals[c] = vals[a] + vals[b]
+            elif opcode[0] == 2: # Multiplication
+                vals[c] = vals[a] * vals[b]
+            elif opcode[0] == 7: # Less Than
+                vals[c] = int(vals[a] < vals[b])
+            elif opcode[0] == 8: # Equals
+                vals[c] = int(vals[a] == vals[b])
+            i += 4
+
+        else:
+            raise InvalidOpcode()
+
+def getEntities():
+    output = getOutput(vals.copy())[1]
+    output.reverse()
+    assert len(output) % 3 == 0
+    entities = [set() for _ in range(5)]
+    while output:
+        pos = (output.pop(), output.pop())
+        tile = output.pop()
+        entities[tile].add(pos)
+    return entities
+
+def part1(entities):
+    print([len(x) for x in entities])
+    print(entities[3], entities[4])
+    return len(entities[2])
+
+class Ball:
+    def __init__(self, x, y):
+        self.x, self.y = 0,0
+        self.dx, self.dy = 0,0
+
+def part2(entities):
+    pass
+
+if __name__ == "__main__":
+    vals = readFile()
+    entities = getEntities()
+    print(f"Part 1: {part1(entities)}")
+    #print(f"Part 2: {part2(entities)}")

2019/13/solution.txt

@@ -0,0 +1 @@
+Part 1: 200