Add 2023/19 py

Author: erikw

2023/19/README.md

@@ -0,0 +1,12 @@
+# Advent of Code - 2023 Day 19
+Here are my solutions to this puzzle.
+
+* Problem instructions: [adventofcode.com/2023/day/19](https://adventofcode.com/2023/day/19)
+* Input: [adventofcode.com/2023/day/19/input](https://adventofcode.com/2023/day/19/input)
+
+Fetch input by exporting `$AOC_SESSION` in your shell and then:
+```bash
+curl -OJLsb session=$AOC_SESSION adventofcode.com/2023/day/19/input
+```
+
+or run `fetch_input.sh` in this directory.

2023/19/fetch_input.sh

@@ -0,0 +1,5 @@
+#!/usr/bin/env sh
+# Make sure $AOC_SESSION is exported before running this script.
+
+curl --remote-name --remote-header-name --silent --fail -A 'https://erikw.me/contact' --cookie "session=$AOC_SESSION" "https://adventofcode.com/2023/day/19/input"
+test "$?" -eq 0 && echo "Fetched input" && exit 0 || echo "Failed to fetch input" && exit 1

2023/19/input1.0

@@ -0,0 +1,17 @@
+px{a<2006:qkq,m>2090:A,rfg}
+pv{a>1716:R,A}
+lnx{m>1548:A,A}
+rfg{s<537:gd,x>2440:R,A}
+qs{s>3448:A,lnx}
+qkq{x<1416:A,crn}
+crn{x>2662:A,R}
+in{s<1351:px,qqz}
+qqz{s>2770:qs,m<1801:hdj,R}
+gd{a>3333:R,R}
+hdj{m>838:A,pv}
+
+{x=787,m=2655,a=1222,s=2876}
+{x=1679,m=44,a=2067,s=496}
+{x=2036,m=264,a=79,s=2244}
+{x=2461,m=1339,a=466,s=291}
+{x=2127,m=1623,a=2188,s=1013}

2023/19/instructions.url

@@ -0,0 +1,2 @@
+[InternetShortcut]
+URL = https://adventofcode.com/2023/day/19

2023/19/output1.0

@@ -0,0 +1 @@
+19114

2023/19/output2.0

@@ -0,0 +1 @@
+167409079868000

2023/19/part1.py

@@ -0,0 +1,70 @@
+#!/usr/bin/env python3
+import sys
+import operator
+from pprint import pprint
+
+
+WORKFLOW_START = "in"
+WORKFLOW_ACCEPT = "A"
+WORKFLOW_REJECT = "R"
+
+OP_FUNCS = {
+    "<" : operator.lt,
+    ">" : operator.gt,
+}
+
+def read_input():
+    with open(sys.argv[1]) as file:
+        workflow_lines, rating_lines = file.read().split("\n\n")
+
+        workflows = {}
+        for workflow_line in workflow_lines.split("\n"):
+            name, rules = workflow_line.split("{")
+            workflows[name] = []
+            for rule in rules[:-1].split(","):
+                if ":" in rule:
+                    condition, target = rule.split(":")
+                    category, cmp, value = condition[0], condition[1], int(condition[2:])
+                    workflows[name].append((category, cmp, value, target))
+                else:
+                    workflows[name].append((rule,))
+
+            ratings = []
+            for rating_line in rating_lines.strip().split("\n"):
+                #  ratings.append({k:v for k, v in zip(["x", "m", "a", "s",], re.findall(r"\d+", rating_line))})
+                ratings.append({})
+                for rating in rating_line.strip("{}").split(","):
+                    category, value = rating.split("=")
+                    ratings[-1][category] = int(value)
+
+        return workflows, ratings
+
+
+def process_parts(workflows, ratings):
+    accepted = []
+    for rating in ratings:
+        workflow = WORKFLOW_START
+        while workflow not in [WORKFLOW_ACCEPT, WORKFLOW_REJECT]:
+            for step in workflows[workflow]:
+                if len(step) == 1:
+                    workflow = step[0]
+                else:
+                    category, cmp, value, target = step
+                    if OP_FUNCS[cmp](rating[category], value):
+                        workflow = target
+                        break
+        if workflow == WORKFLOW_ACCEPT:
+            accepted.append(rating)
+    return accepted
+
+
+
+def main():
+    workflows, ratings = read_input()
+    accepted = process_parts(workflows, ratings)
+
+    rating_sum = sum([sum(a.values()) for a in accepted])
+    print(rating_sum)
+
+if __name__ == '__main__':
+	main()

2023/19/part2.py

@@ -0,0 +1,106 @@
+#!/usr/bin/env python3
+import sys
+import operator
+from pprint import pprint
+import copy
+from math import prod
+
+
+RANGE_MIN = 1
+RANGE_MAX = 4000
+
+WORKFLOW_START = "in"
+WORKFLOW_ACCEPT = "A"
+WORKFLOW_REJECT = "R"
+
+OP_FUNCS = {
+    "<" : operator.lt,
+    ">" : operator.gt,
+}
+
+def read_input():
+    with open(sys.argv[1]) as file:
+        workflow_lines, rating_lines = file.read().split("\n\n")
+
+        # Add Accpet/Reject as own workflows to make recursion easier.
+        workflows = { 
+            WORKFLOW_ACCEPT: (WORKFLOW_ACCEPT,),
+            WORKFLOW_REJECT: (WORKFLOW_REJECT,),
+        }
+        for workflow_line in workflow_lines.split("\n"):
+            name, rules = workflow_line.split("{")
+            workflows[name] = []
+            for rule in rules[:-1].split(","):
+                if ":" in rule:
+                    condition, target = rule.split(":")
+                    category, cmp, value = condition[0], condition[1], int(condition[2:])
+                    workflows[name].append((category, cmp, value, target))
+                else:
+                    workflows[name].append((rule,))
+
+            ratings = []
+            for rating_line in rating_lines.strip().split("\n"):
+                #  ratings.append({k:v for k, v in zip(["x", "m", "a", "s",], re.findall(r"\d+", rating_line))})
+                ratings.append({})
+                for rating in rating_line.strip("{}").split(","):
+                    category, value = rating.split("=")
+                    ratings[-1][category] = int(value)
+
+        return workflows, ratings
+
+
+# Ranges are inclusive
+def find_acceptable_ranges(workflows, workflow=WORKFLOW_START, step=0, ranges={"x": [RANGE_MIN, RANGE_MAX], "m": [RANGE_MIN, RANGE_MAX], "a": [RANGE_MIN, RANGE_MAX], "s": [RANGE_MIN, RANGE_MAX]}):
+    workflow_step = workflows[workflow][step]
+    if len(workflow_step) == 1:
+        if workflow_step[0] == WORKFLOW_ACCEPT:
+            return [ranges]
+        elif workflow_step[0] == WORKFLOW_REJECT:
+            return []
+        else:
+            return find_acceptable_ranges(workflows, workflow_step[0], 0, ranges)
+
+    category, cmp, value, target = workflow_step
+
+    # Recurse for step condition true
+    ranges_cond_true = []
+    ranges_rec_true = copy.deepcopy(ranges)
+    if cmp == "<":
+        ranges_rec_true[category][1] = min(ranges_rec_true[category][1], value - 1)
+        if ranges_rec_true[category][1] < ranges_rec_true[category][0]:
+            ranges_rec_true = None
+    else:
+        ranges_rec_true[category][0] = max(ranges_rec_true[category][0], value + 1)
+        if ranges_rec_true[category][0] > ranges_rec_true[category][1]:
+            ranges_rec_true = None
+    if ranges_rec_true:
+        ranges_cond_true = find_acceptable_ranges(workflows, target, 0, ranges_rec_true)
+
+
+    # Recurse for step condition false
+    ranges_cond_false = []
+    ranges_rec_false = copy.deepcopy(ranges)
+    if cmp == "<":
+        ranges_rec_false[category][0] = max(ranges_rec_false[category][0], value)
+        if ranges_rec_false[category][0] > ranges_rec_false[category][1]:
+            ranges_rec_false = None
+    else:
+        ranges_rec_false[category][1] = min(ranges_rec_false[category][1], value)
+        if ranges_rec_false[category][1] < ranges_rec_false[category][0]:
+            ranges_rec_false = None
+    if ranges_rec_false:
+        ranges_cond_false = find_acceptable_ranges(workflows, workflow, step + 1, ranges_rec_false)
+
+    return ranges_cond_true + ranges_cond_false
+
+
+
+def main():
+    workflows = read_input()[0]
+    ranges = find_acceptable_ranges(workflows)
+
+    combinations = sum(prod((hi - lo + 1 for lo, hi in range.values())) for range in ranges)
+    print(combinations)
+
+if __name__ == '__main__':
+	main()