Adding day 16 part 2... stupid boolean logic and off by one errors... probabyl. Whatever a star is a star

Author: Joe Webster

Diff for: 16/__init__.py

@@ -1,7 +1,15 @@
+import pprint
+
+import sys
+sys.path.append('..')
+
+import lib.text
+
 class BITSPacketDecoder(object):
     def __init__(self, packet):
         self.packet = packet
         self.bits = self.hex2bin(self.packet)
+        self.bit_labels = '' 
         self.index = 0
 
     def hex2bin(self, hex_string):
@@ -15,24 +23,29 @@ def bits_left(self):
         ret = len(self.bits) - self.index
         return ret
 
-    def read(self, read_len):
+    def read(self, read_len, bit_label):
         if self.bits_left() < read_len:
             print("read underrun")
             return None
 
         ret = self.bits[self.index:self.index+read_len]
 
-        #print(self.bits)
-        #print(' ' * self.index + '*' * read_len + ' = ' + ret + ' (' + str(int(ret, 2)) + ')')
-        #print()
+        preview_width = 60
+        skip = max(self.index - preview_width, 0)
+
+        print(self.bits[skip:skip+preview_width*2])
+        print(self.bit_labels[skip:] + lib.text.bcolor('green', bit_label * read_len) + " -> %s (dec %s)" % (ret, str(int(ret, 2))))
+        print()
+
+        self.bit_labels += bit_label * read_len
 
         self.index += read_len
 
         return ret
 
     def read_packet(self):
-        version = int(self.read(3), 2)
-        type_id = int(self.read(3), 2)
+        version = int(self.read(3, 'V'), 2)
+        type_id = int(self.read(3, 'T'), 2)
 
         print('version: %s type_id: %s' % (version, type_id))
 
@@ -47,28 +60,38 @@ def parse_payload_4(self, version, type_id):
         bit_string = ""
         more = 1
         while more:
-            more = int(self.read(1))
-            bit_string += self.read(4)
+            more = int(self.read(1, 'n'))
+            bit_string += self.read(4, 'N')
 
         return {'version': version, 'type_id': type_id, 'literal': int(bit_string, 2)}
 
     def parse_payload_op(self, version, type_id):
         subpackets = []
 
-        length_type_id = int(self.read(1))
+        length_type_id = int(self.read(1, 'I'))
+
+        subpacket_length = None
+        subpacket_count = None
 
         if length_type_id == 0:
-            subpacket_length = int(self.read(15), 2)
+            subpacket_length = int(self.read(15, 'L'), 2)
+            bit_stop = self.index + subpacket_length
         elif length_type_id == 1:
-            subpacket_count = int(self.read(11), 2)
+            subpacket_count = int(self.read(11, 'C'), 2)
+
+        packet_count = 0
+        while (
+                (subpacket_count and packet_count < subpacket_count)
+                or
+                (subpacket_length and self.index < bit_stop)
+            ) and self.bits_left() >= 11:
 
-        while self.bits_left() > 12:
             subpacket = self.read_packet()
+            packet_count += 1
             if subpacket:
                 subpackets.append(subpacket)
             else:
-                print("no subpacket?, breaking")
-                break
+                raise ValueError('no subpacket when expecting subpacket')
 
         return {'version': version, 'type_id': type_id, 'subpackets': subpackets}
 
@@ -89,15 +112,79 @@ def get_version_sum(self, packet):
 
         return version_sum
 
-    def parse_packets(self, data):
-        print(data)
-        bd = BITSPacketDecoder(data)
-        print(bd.bits)
-        print()
+    def evaluate_packet(self, packet, depth=0):
+        type_id = packet['type_id']
+
+        if type_id == 4 and 'subpackets' in packet:
+            raise ValueError('WTF')
+
+        if type_id == 4:
+            return packet['literal']
+
+        if 'subpackets' in packet:
+            values = []
+            for subpacket in packet['subpackets']:
+                values.append(self.evaluate_packet(subpacket, depth+1))
+
+            print((' ' * depth) + str(depth) + ' eval %s of %s' % (type_id, values))
+            
+            if type_id == 0:
+                ret = sum(values)
+                print("sum %s = %s" % (values, ret))
+                return ret 
+            elif type_id == 1:
+                product = 1
+                for v in values:
+                    product *= v
+                print("product %s = %s" % (values, product))
+                return product
+            elif type_id == 2:
+                ret = min(values)
+                print("min %s = %s" % (values, ret))
+                return ret 
+            elif type_id == 3:
+                ret = max(values)
+                print("max %s = %s" % (values, ret))
+                return ret 
+            elif type_id == 4:
+                raise ValueError("WTF srsly")
+            elif type_id == 5:
+                ret = 1 if values[0] > values[1] else 0
+                print("%s gt %s = %s" % (values[0], values[1], ret))
+                return ret
+            elif type_id == 6:
+                ret = 1 if values[0] < values[1] else 0
+                print("%s lt %s = %s" % (values[0], values[1], ret))
+                return ret
+            elif type_id == 7:
+                ret = 1 if values[0] == values[1] else 0
+                print("%s eq %s = %s" % (values[0], values[1], ret))
+                return ret 
+            else:
+                raise ValueError('Unknown type_id %s' % type_id)
+
+        print('mystery packet')
+        pprint.pprint(packet)
+        raise ValueError('WTF')
 
-        packets = bd.read_packet()
+    def parse_packets(self, transmissions):
+        ret = {} 
+        for transmission in transmissions:
+            print(transmission)
 
-        return packets
+            bd = BITSPacketDecoder(transmission)
+
+            parsed_transmission = bd.read_packet()
+            print(parsed_transmission)
+
+            if bd.bits_left():
+                leftovers = bd.read(bd.bits_left(), 'x')
+                if int(leftovers):
+                    raise ValueError("Left bits on the table: %s" % leftovers) 
+
+            ret.update({transmission: parsed_transmission})
+
+        return ret 
 
 def get_data():
     return [l.rstrip() for l in open('data.txt', 'r').readlines()]
@@ -108,20 +195,24 @@ def get_test_data():
 def solution_part_1(data):
     bits = BITS()
     bits.load_data(data) 
-    packets = bits.parse_packets(data)
-    version_sum = bits.get_version_sum(packets)
-    print('version_sum', version_sum)
+    parsed_transmissions = bits.parse_packets(data)
+
+    for transmission, parsed_transmission in parsed_transmissions.items():
+        version_sum = bits.get_version_sum(parsed_transmission)
+        print('version_sum', version_sum)
 
 def solution_part_2(data):
     bits = BITS()
     bits.load_data(data) 
-    packets = bits.parse_packets(data)
-    result = bits.evaluate_packets(packets)
-    print('eval results', result)
+    parsed_transmissions = bits.parse_packets(data)
+    for transmission, parsed_transmission in parsed_transmissions.items():
+        print(transmission)
+        result = bits.evaluate_packet(parsed_transmission)
+        print('eval results', result)
 
 if __name__ == '__main__':
-    solution_part_1(get_test_data())
-    solution_part_1(get_data())
+    #solution_part_1(get_test_data())
+    #solution_part_1(get_data())
 
     #solution_part_2(get_test_data())
-    #solution_part_2(get_data())
+    solution_part_2(get_data())

Diff for: 16/test_data.txt

@@ -5,3 +5,11 @@ EE00D40C823060
 620080001611562C8802118E34
 C0015000016115A2E0802F182340
 A0016C880162017C3686B18A3D4780
+C200B40A82
+04005AC33890
+880086C3E88112
+CE00C43D881120
+D8005AC2A8F0
+F600BC2D8F
+9C005AC2F8F0
+9C0141080250320F1802104A08

Diff for: lib/text/__init__.py

@@ -0,0 +1,14 @@
+def bcolor(color, text):
+    colors = {
+        'bred': '\033[31;1m',
+        'redbg': '\033[41m',
+        'red': '\033[91m',
+        'green': '\033[92m',
+        'greenbg': '\033[42m',
+        'yellow': '\033[93m',
+        'blue': '\033[94m',
+        'bluebg': '\033[44m',
+        'reset': '\033[0m'
+    }
+
+    return colors[color] + str(text) + colors['reset']