blob: 56a31b611a969605556fa8c3573cf550a9b213aa (
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
|
(load "lib.lisp")
(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 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)))
|
