Day 9, 2017 - Parts I & II

Author: scottshepard

2017/day09.py

@@ -0,0 +1,129 @@
+# --- Day 9: Stream Processing ---
+#
+# A large stream blocks your path. According to the locals, it's not safe to
+# cross the stream at the moment because it's full of garbage. You look down at
+# the stream; rather than water, you discover that it's a stream of characters.
+#
+# You sit for a while and record part of the stream (your puzzle input).
+# The characters represent groups - sequences that begin with { and end with }.
+# Within a group, there are zero or more other things, separated by commas:
+# either another group or garbage. Since groups can contain other groups,
+# a } only closes the most-recently-opened unclosed group - that is,
+# they are nestable. Your puzzle input represents a single, large group which
+# itself contains many smaller ones.
+#
+# Sometimes, instead of a group, you will find garbage.
+# Garbage begins with < and ends with >.
+# Between those angle brackets, almost any character can appear,
+# including { and }. Within garbage, < has no special meaning.
+#
+# In a futile attempt to clean up the garbage, some program has canceled some
+# of the characters within it using !: inside garbage, any character that
+# comes after ! should be ignored, including <, >, and even another !.
+#
+# You don't see any characters that deviate from these rules.
+# Outside garbage, you only find well-formed groups, and garbage always
+# terminates according to the rules above.
+#
+# Here are some self-contained pieces of garbage:
+#
+# <>, empty garbage.
+# <random characters>, garbage containing random characters.
+# <<<<>, because the extra < are ignored.
+# <{!>}>, because the first > is canceled.
+# <!!>, because the second ! is canceled, allowing the > to terminate the garbage.
+# <!!!>>, because the second ! and the first > are canceled.
+# <{o"i!a,<{i<a>, which ends at the first >.
+# Here are some examples of whole streams and the number of groups they contain:
+#
+# {}, 1 group.
+# {{{}}}, 3 groups.
+# {{},{}}, also 3 groups.
+# {{{},{},{{}}}}, 6 groups.
+# {<{},{},{{}}>}, 1 group (which itself contains garbage).
+# {<a>,<a>,<a>,<a>}, 1 group.
+# {{<a>},{<a>},{<a>},{<a>}}, 5 groups.
+# {{<!>},{<!>},{<!>},{<a>}}, 2 groups (since all but the last > are canceled).
+#
+# Your goal is to find the total score for all groups in your input.
+# Each group is assigned a score which is one more than the score of the group
+# that immediately contains it. (The outermost group gets a score of 1.)
+#
+# {}, score of 1.
+# {{{}}}, score of 1 + 2 + 3 = 6.
+# {{},{}}, score of 1 + 2 + 2 = 5.
+# {{{},{},{{}}}}, score of 1 + 2 + 3 + 3 + 3 + 4 = 16.
+# {<a>,<a>,<a>,<a>}, score of 1.
+# {{<ab>},{<ab>},{<ab>},{<ab>}}, score of 1 + 2 + 2 + 2 + 2 = 9.
+# {{<!!>},{<!!>},{<!!>},{<!!>}}, score of 1 + 2 + 2 + 2 + 2 = 9.
+# {{<a!>},{<a!>},{<a!>},{<ab>}}, score of 1 + 2 = 3.
+#
+# What is the total score for all groups in your input?
+#
+# ------------------------------------------------------------------------------
+
+import re
+import sys
+import os
+
+sys.setrecursionlimit(17000)
+
+def solve1(chars, ignore = False, garbage = False, open_groups = 0):
+    if(len(chars) == 0):
+        return 0
+    char = chars[0]
+    if ignore:
+        return solve1(chars[1:], False, garbage, open_groups)
+    if char == '!':
+        return solve1(chars[1:], True, garbage, open_groups)
+    if garbage:
+        if char == '>':
+            return solve1(chars[1:], ignore, False, open_groups)
+        else:
+            return solve1(chars[1:], ignore, garbage, open_groups)
+    if char == '{':
+        return solve1(chars[1:], ignore, garbage, open_groups + 1)
+    elif char == '}':
+        if open_groups > 0:
+            return open_groups + solve1(chars[1:], ignore, garbage, open_groups - 1)
+        else:
+            return solve1(chars[1:], ignore, garbage, open_groups)
+    elif char == '<':
+        return solve1(chars[1:], ignore, True, open_groups)
+    else:
+        return solve1(chars[1:], ignore, garbage, open_groups)
+
+def solve2(chars, ignore = False, garbage = False, open_groups = 0):
+    if(len(chars) == 0):
+        return 0
+    char = chars[0]
+    if ignore:
+        return solve2(chars[1:], False, garbage, open_groups)
+    if char == '!':
+        return solve2(chars[1:], True, garbage, open_groups)
+    if garbage:
+        if char == '>':
+            return solve2(chars[1:], ignore, False, open_groups)
+        else:
+            return 1 + solve2(chars[1:], ignore, garbage, open_groups)
+    if char == '{':
+        return solve2(chars[1:], ignore, garbage, open_groups + 1)
+    elif char == '}':
+        if open_groups > 0:
+            return solve2(chars[1:], ignore, garbage, open_groups - 1)
+        else:
+            return solve2(chars[1:], ignore, garbage, open_groups)
+    elif char == '<':
+        return solve2(chars[1:], ignore, True, open_groups)
+    else:
+        return solve2(chars[1:], ignore, garbage, open_groups)
+
+if __name__ == '__main__':
+    file_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "inputs/day09.txt")
+    if len(sys.argv) == 2:
+        data = sys.argv[1]
+    else:
+        f = open(file_path)
+        data = f.read()
+    print(solve1(data))
+    print(solve2(data))