advent-2024/p17/p17.org

solution to p17

Load program

  (require 'dash)

  (defun replace-regexp-from-top (a b)
    (goto-char (point-min))
    (replace-regexp a b))

    (with-temp-buffer
      (insert-file-contents "input")
      (replace-regexp-from-top "Register \\(.\\): \\(.*\\)$" "(setq \\1 \\2)")

      (replace-regexp-from-top "\\(.\\),\\(.\\)" "(\\1 \\2)")
      (replace-regexp-from-top "," " ")
      (replace-regexp-from-top "Program: \\(.*\\)$" "(setq program '(\\1))")

      (eval-buffer))

Convert the opcodes into instructions

  (let ((opcode-alist '( (0 . adv)
			 (1 . bxl)
			 (2 . bst)
			 (3 . jnz)
			 (4 . bxc)
			 (5 . out)
			 (6 . bdv)
			 (7 . cdv))))
    (setq proggo (--map (cons (cdr (assoc (car it) opcode-alist)) (cdr it)) program)))

bst	4
bxl	5
cdv	5
bxl	6
adv	3
bxc	1
out	5
jnz	0

Now define the instructions and run, for part 1

  (defun combo (c)
    (let ((combo-alist `( (4 . ,A)
                          (5 . ,B)
                          (6 . ,C))))
      (if (< c 4) c
    (cdr (assoc c combo-alist)))))

  (defun aux-adv (c)
    (ash A (* -1 (combo c))))

  (defun adv (c)
    (setq A (aux-adv c)))

  (defun bdv (c)
    (setq B (aux-adv c)))

  (defun cdv (c)
    (setq C (aux-adv c)))

  (defun bxl (l)
    (setq B (logxor l B)))

  (defun bst (c)
    (setq B (mod (combo c) 8)))

  (defun out (c)
    (push (mod (combo c) 8) so))

  (defun bxc (l)
    (setq B (logxor B C))
)
  (defun jnz (l)
    (unless (eq A 0)
      (setq ip (- (/ l 2) 1))))

  (defun exec (pr)
    (setq so nil
      ip 0
      stack-trace nil)

    (while (nth ip pr)
      (push (list A B C ip (nth ip pr)) stack-trace)
      (eval (nth ip pr))
      (setq ip (1+ ip)))

    (substring (apply #'concat (-map (-partial #'format "%d,") (reverse so))) 0 -1))

  (exec proggo)

3

now for part 2 we create the initial value 3 bits at a time

  (defun prep-reg (data)
    (apply #'+ (--map-indexed (ash it (* 3 it-index)) data)) )

  (defun setup-registers (data)
    (setq A (prep-reg data)
   B 0
   C 0))

  (defun exec (pr data)
    (let ((so nil)
   (ip 0)
   (stack-trace nil))

(setup-registers data)

(while (nth ip pr)
 (eval (nth ip pr))
 (setq ip (1+ ip)))

(reverse so)))


  (defun grow-data (data)
    (--mapcat (-map (lambda (i) (append it (list i))) (-iota 8)) data))


  (setq data (-last-item (-iterate #'grow-data '(nil) 4))
 target (-flatten program))

  (defun good-data (data)
    (let ((n (- (length (car data)) 2)))
(--filter (equal (-take n (exec proggo it)) (-take n target)) (grow-data data))))
  (setq aaaa (-last-item (-iterate #'good-data data 15)))
(-min (-map 'prep-reg (--filter (equal (exec proggo it) target) aaaa)))

105981155568026