Advent of Code #9

aoc9-deck.lisp

(defun play-game (max-players last-marble)
  (let ((scores (make-hash-table))
        (marbles (deque 0)))
    (dotimes (marble (1+ last-marble))
      (case (mod (1+ marble) 23)
        (0 (drotate marbles 7)
           (incf (gethash (rem marble max-players) scores 0)
                 (+ 1 marble (popl marbles))))
        (t (drotate marbles -2)
           (pushl (1+ marble) marbles))))
    (reduce 'max (cons 0 (vals scores)))))

aoc9.lisp

(defun play-game (max-players last-marble)
  (let ((scores (make-hash-table))
        (marbles '#1=(0 . #1#)))
    (dotimes (marble (1+ last-marble))
      (case (mod (1+ marble) 23)
        (0 (let ((end (* 2 (floor marble 23))))
             (setf marbles (nthcdr (- marble end 6) marbles)
                   (cdr (nthcdr (- marble end) marbles)) (cdr marbles))
             (incf (gethash (rem marble max-players) scores 0)
                   (+ 1 marble (pop marbles)))))
        (t (setf (cddr marbles) (cons (1+ marble) (cddr marbles))
                 marbles (funcall (if (= 0 marble) 'cdr 'cddr) marbles)))))
    (reduce 'max (cons 0 (vals scores)))))

deque.lisp

(ql:quickload :rutilsx)
(use-package :rutilsx)

(defstruct (deque (:conc-name nil))
  beg end)

(defstruct (dnode (:conc-name nil))
  item lt rt)

(defun pushr (item deque)
  (:= (end deque)
      (if-it (end deque)
             (:= (rt it) (make-dnode :item item :lt it))
             (let ((node (make-dnode :item item)))
               (:= (beg deque) node
                   (end deque) node)))))

(defun pushl (item deque)
  (:= (beg deque)
      (if-it (beg deque)
             (:= (lt it) (make-dnode :item item :rt it))
             (let ((node (make-dnode :item item)))
               (:= (beg deque) node
                   (end deque) node)))))

(defun popr (deque)
  (when-it (end deque)
    (:= (end deque) (lt it))
    (if-it (end deque)
           (:= (rt it) nil)
           (:= (beg deque) nil))
    (item it)))

(defun popl (deque)
  (when-it (beg deque)
    (:= (beg deque) (rt it))
    (if-it (beg deque)
           (:= (lt it) nil)
           (:= (end deque) nil))
    (item it)))

(defun dreverse (deque)
  (loop :for cur := (beg deque) :then (lt cur) :while cur :do
    (rotatef (lt cur) (rt cur))))

(defun drotate (deque &optional (n 1))
  (if (plusp n)
      (loop :repeat n :do
        (pushl (popr deque) deque))
      (loop :repeat (- n) :do
        (pushr (popl deque) deque)))
  deque)

(defun deque (&rest items)
  (let ((d (make-deque)))
    (dolist (item items)
      (pushr item d))
    d))