87 lines
2.9 KiB
Common Lisp
87 lines
2.9 KiB
Common Lisp
(ql:quickload :alexandria)
|
|
|
|
(defparameter *input-file* #P"input.txt")
|
|
(defvar *input*)
|
|
|
|
(defvar *program*)
|
|
(defvar *input-fn*)
|
|
(defvar *output-fn*)
|
|
|
|
(defun opcode (pc)
|
|
(mod (aref *program* pc) 100))
|
|
|
|
(defun parameter-mode (pc index)
|
|
(mod (truncate (aref *program* pc) (expt 10 (+ 1 index))) 10))
|
|
|
|
(defun parameter (pc index)
|
|
(ecase (parameter-mode pc index)
|
|
(1 (aref *program* (+ index pc)))
|
|
(0 (aref *program* (aref *program* (+ pc index))))))
|
|
|
|
(defun (setf parameter) (new-value pc index)
|
|
(ecase (parameter-mode pc index)
|
|
(0 (setf (aref *program* (aref *program* (+ pc index))) new-value))
|
|
(1 (error "Cannot write with a parameter in immediate mode"))))
|
|
|
|
(defun execute-instruction (pc)
|
|
(ecase (opcode pc)
|
|
(99 (return-from execute-instruction))
|
|
(1 (setf (parameter pc 3) (+ (parameter pc 1) (parameter pc 2)))
|
|
(execute-instruction (+ pc 4)))
|
|
(2 (setf (parameter pc 3) (* (parameter pc 1) (parameter pc 2)))
|
|
(execute-instruction (+ pc 4)))
|
|
(3 (setf (parameter pc 1) (funcall *input-fn*))
|
|
(execute-instruction (+ pc 2)))
|
|
(4 (funcall *output-fn* (parameter pc 1))
|
|
(execute-instruction (+ pc 2)))
|
|
(5 (if (/= 0 (parameter pc 1))
|
|
(execute-instruction (parameter pc 2))
|
|
(execute-instruction (+ pc 3))))
|
|
(6 (if (= 0 (parameter pc 1))
|
|
(execute-instruction (parameter pc 2))
|
|
(execute-instruction (+ pc 3))))
|
|
(7 (if (< (parameter pc 1) (parameter pc 2))
|
|
(setf (parameter pc 3) 1)
|
|
(setf (parameter pc 3) 0))
|
|
(execute-instruction (+ pc 4)))
|
|
(8 (if (= (parameter pc 1) (parameter pc 2))
|
|
(setf (parameter pc 3) 1)
|
|
(setf (parameter pc 3) 0))
|
|
(execute-instruction (+ pc 4)))))
|
|
|
|
(defun execute (program &key (input 'input) (output 'output))
|
|
(let ((*program* program)
|
|
(*input-fn* input)
|
|
(*output-fn* output))
|
|
(execute-instruction 0)))
|
|
|
|
(defun parse-program (program-string)
|
|
(map 'vector #'parse-integer (uiop:split-string program-string :separator ",")))
|
|
|
|
(defun amplify (phases)
|
|
(let ((amp-input 0))
|
|
(loop for phase in phases
|
|
do (let ((program (alexandria:copy-array *program*))
|
|
(inputs (list phase amp-input))
|
|
(output nil))
|
|
(execute program :input (lambda () (pop inputs)) :output (lambda (x) (setf output x)))
|
|
(setf amp-input output)))
|
|
amp-input))
|
|
|
|
(defun max-thrust ()
|
|
(let ((res nil))
|
|
(alexandria:map-permutations (lambda (x) (push (amplify x) res)) '(0 1 2 3 4))
|
|
(apply #'max res)))
|
|
|
|
(assert (= 43210 (let ((*program* (parse-program "3,15,3,16,1002,16,10,16,1,16,15,15,4,15,99,0,0")))
|
|
(max-thrust))))
|
|
|
|
(assert (= 54321 (let ((*program* (parse-program "3,23,3,24,1002,24,10,24,1002,23,-1,23,101,5,23,23,1,24,23,23,4,23,99,0,0")))
|
|
(max-thrust))))
|
|
|
|
(assert (= 65210 (let ((*program* (parse-program "3,31,3,32,1002,32,10,32,1001,31,-2,31,1007,31,0,33,1002,33,7,33,1,33,31,31,1,32,31,31,4,31,99,0,0,0")))
|
|
(max-thrust))))
|
|
|
|
(defun part1 ()
|
|
(let ((*program* (parse-program (uiop:read-file-string *input-file*))))
|
|
(max-thrust)))
|