aboutsummaryrefslogtreecommitdiff
path: root/2022/puzzle-3.lisp
blob: e2e17ccf301e8550ff5b3f19fe41c96f079899fb (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
(defvar input (uiop:read-file-string "3-input"))

(defun split-string-in-two (s)
  (let ((len (length s)))
    (list (subseq s 0 (/ len 2)) (subseq s (/ len 2)))))

(defvar inputs (with-input-from-string (s input)
                 (loop
                   for line = (read-line s nil)
                   until (null line)
                   collect (split-string-in-two line))))

(defun string-to-clist (str)
  (loop for char across str collect char))

(defun common-types (s1 s2)
  (car (intersection
        (string-to-clist s1)
        (string-to-clist s2))))

(defvar shared (mapcar (lambda (x)
                    (destructuring-bind (s1 s2) x
                      (common-types s1 s2)))
                  inputs))

(defun priority-map (c)
  (if (upper-case-p c)
      (+ 27 (- (char-code c) (char-code #\A)))
      (+ 1 (- (char-code c) (char-code #\a)))))

(defvar round-1-answer (reduce #'+ (mapcar #'priority-map shared)))

;; Round 2

;; Simple recursive algorithm which produces consecutive groups of 3 elements
(defun group-by-3 (lst)
  (if (null lst)
      nil
      (cons
       (list (car lst) (car (cdr lst)) (car (cdr (cdr lst))))
       (group-by-3 (cdr (cdr (cdr lst)))))))

;; Note the use of group-by-3 here
(defvar inputs (group-by-3
                (with-input-from-string (s input)
                  (loop
                    for line = (read-line s nil)
                    until (null line)
                    collect line))))

;; Extend intersection to three
(defun common-types-3 (s1 s2 s3)
  (car
   (intersection
    (string-to-clist s1)
    (intersection
     (string-to-clist s2)
     (string-to-clist s3)))))

;; Extend the destructuring bind and use of common-types-3
(defvar shared (mapcar (lambda (x)
                    (destructuring-bind (s1 s2 s3) x
                      (common-types-3 s1 s2 s3)))
                  inputs))

;; Same as before
(defvar round-2-answer (reduce #'+ (mapcar #'priority-map shared)))