From 33898c4eea337128e26fc5c7eaf245b12c8bd452 Mon Sep 17 00:00:00 2001
From: Aryadev Chavali <aryadev@aryadevchavali.com>
Date: Mon, 26 Jun 2023 08:35:43 +0100
Subject: (*->2022)~made it clear what advent of code I'm doing

---
 2022/puzzle-4.lisp | 59 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 59 insertions(+)
 create mode 100644 2022/puzzle-4.lisp

(limited to '2022/puzzle-4.lisp')

diff --git a/2022/puzzle-4.lisp b/2022/puzzle-4.lisp
new file mode 100644
index 0000000..04c7bfb
--- /dev/null
+++ b/2022/puzzle-4.lisp
@@ -0,0 +1,59 @@
+;; Example input: a-b,c-d which denotes [a,b] and [c,d]
+
+;; We want to find if [c,d] < [a,b] or vice versa (complete inclusion)
+;; and since we're working with integers, it's simply checking if the
+;; bounds are included i.e. c in [a,b] and d in [a,b]
+
+(defvar input (uiop:read-file-string "2022/4-input"))
+
+(defun parse-bound (str)
+  "Given STR=\"a-b\" return (a b)"
+  (let* ((sep (search "-" str))
+         (first (subseq str 0 sep))
+         (second (subseq str (+ sep 1))))
+    (list (parse-integer first) (parse-integer second))))
+
+(defvar completed-parse
+  (with-input-from-string (s input)
+    (loop for line = (read-line s nil)
+          until (null line)
+          collect
+          ;; given a-b,c-d we want ((a b) (c d))
+          (let* ((sep (search "," line))
+                 (first-bound (subseq line 0 sep))
+                 (second-bound (subseq line (+ sep 1))))
+            (list (parse-bound first-bound) (parse-bound second-bound))))))
+
+(defun complete-inclusion (first-bound second-bound)
+  (destructuring-bind (a b) first-bound
+    (destructuring-bind (c d) second-bound
+      (or
+       (and
+        (>= a c) (<= a d)
+        (>= b c) (<= b d))
+       (and
+        (>= c a) (<= c b)
+        (>= d a) (<= d b))))))
+
+(defvar round-1-answer (length (remove-if #'null
+                                          (mapcar (lambda (pair)
+                                               (destructuring-bind (first second) pair
+                                                 (complete-inclusion first second)))
+                                             completed-parse))))
+
+;; Round 2: any overlap at all.  Basically just overhaul the inclusion
+;; function and then do the same answer checking.
+(defun any-inclusion (first second)
+  (destructuring-bind (a b) first
+    (destructuring-bind (c d) second
+      ;; How about doing this through negation?  [a,b] does not overlap with [c,d] at all if either b < c or a > d.
+      (not
+       (or
+        (< b c)
+        (> a d))))))
+
+(defvar round-2-answer (length (remove-if #'null
+                                          (mapcar (lambda (pair)
+                                               (destructuring-bind (first second) pair
+                                                 (any-inclusion first second)))
+                                             completed-parse))))
-- 
cgit v1.2.3-13-gbd6f