From 21622cc051473d60f10bee72c93ee81a939b7346 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?David=20Doblas=20Jim=C3=A9nez?=
 <david.doblas-jimenez@xfel.eu>
Date: Thu, 28 Apr 2022 10:24:38 +0200
Subject: [PATCH] Solution to problem 9 in Python

---
 src/Year_2017/P9.py | 133 ++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 133 insertions(+)
 create mode 100644 src/Year_2017/P9.py

diff --git a/src/Year_2017/P9.py b/src/Year_2017/P9.py
new file mode 100644
index 0000000..d5c857f
--- /dev/null
+++ b/src/Year_2017/P9.py
@@ -0,0 +1,133 @@
+# --- 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?
+
+with open("files/P9.txt") as f:
+    data = [line for line in f.read().strip().split()][0]
+
+
+def part_1() -> None:
+    group_count, score = 0, 0
+    i = 0
+    while i < len(data):
+        if data[i] == "{":
+            group_count += 1
+            score += group_count
+        elif data[i] == "}":
+            group_count -= 1
+        elif data[i] == "<":
+            i += 1
+            while data[i] != ">" and i < len(data):
+                if data[i] == "!":
+                    i += 1
+                i += 1
+        i += 1
+
+    print(f"The total score is {score}")
+
+
+# --- Part Two ---
+
+# Now, you're ready to remove the garbage.
+
+# To prove you've removed it, you need to count all of the characters within
+# the garbage. The leading and trailing < and > don't count, nor do any
+# canceled characters or the ! doing the canceling.
+
+#     <>, 0 characters.
+#     <random characters>, 17 characters.
+#     <<<<>, 3 characters.
+#     <{!>}>, 2 characters.
+#     <!!>, 0 characters.
+#     <!!!>>, 0 characters.
+#     <{o"i!a,<{i<a>, 10 characters.
+
+# How many non-canceled characters are within the garbage in your puzzle input?
+
+
+def part_2() -> None:
+    group_count, score, garbage_chars = 0, 0, 0
+    i = 0
+    while i < len(data):
+        if data[i] == "{":
+            group_count += 1
+            score += group_count
+        elif data[i] == "}":
+            group_count -= 1
+        elif data[i] == "<":
+            i += 1
+            while data[i] != ">" and i < len(data):
+                if data[i] == "!":
+                    i += 1
+                else:
+                    garbage_chars += 1
+                i += 1
+        i += 1
+
+    print(f"There are {garbage_chars} non-cancelled characters in the garbage")
+
+
+if __name__ == "__main__":
+    part_1()
+    part_2()