#+title: Solution to p10

#+begin_src emacs-lisp :results none
  (with-temp-buffer
    (insert-file-contents "input")
    (advent/replace-multiple-regex-buffer
     '(("," . " ")
       ("^" . "(")
       ("$" . ")")
       ("\\[" . "\"")
       ("\\]" . "\"")
       ("{" . "(")
       ("}" . ")")
       ))
    (goto-char (point-min))
    (insert "(setq data '(")
    (goto-char (point-max))
    (insert "))")
    (eval-buffer))
#+end_src
#+begin_src emacs-lisp :results none
  (defun zero-one (n)
    (if (eq n ?#) 1 0))

  (setq cleanedup-data (--map (cons (-map #'zero-one (advent/split-string-into-char-list (car it))) (cdr it)) data))
  #+end_src



for part 1 we do not need the last item
#+begin_src emacs-lisp
  (setq machines (--map (-drop-last 1 it) cleanedup-data))

  (defun to-bin (l)
    (-sum  (--map-indexed (* it (expt 2 it-index)) l)))

  (defun to-mask (l)
    (-sum (--map (expt 2 it) l)))

  (setq mask-machines (--map (cons (to-bin (car it)) (-map #'to-mask (cdr it))) machines))

  (-sum
   (-map (lambda (machine) 
  	 (-min (-map 'length  (--filter (= (car machine) (apply 'logxor it))
  					(-powerset (cdr machine))))))
         mask-machines))
#+end_src

#+RESULTS:
: 404

This approach blows the stack
#+begin_src emacs-lisp
  (setq machines (--map (-rotate 1 (cdr it)) data))

  (defun apply-button (joltage button)
    (--map-indexed (if (-contains-p button it-index) (- it 1) it) joltage))

  (defun good-buttons (machine)
    (-filter (lambda (button) (--every (< 0 (nth it (car machine))) button)) (cdr machine)))

  (defun solve-machines (machines)
    (-mapcat (lambda (machine)
  	     (if (= 0 (-sum (car machine))) (list machine)
  	       (--map (cons it (cdr machine)) (--map (apply-button (car machine) it) (good-buttons machine)))))
  	    machines ))

  (-iterate 'solve-machines (list (car machines)) 19)

#+end_src

Instead, go depth first and memoize for the win
#+begin_src emacs-lisp
  (setq machines (--map (-rotate 1 (cdr it)) data)
        machines (--map (cons (car it) (--sort (> (length it) (length other)) (cdr it))) machines))

  (defun apply-button (joltage button)
    (--map-indexed (if (-contains-p button it-index) (- it 1) it) joltage))

    (defun good-buttons (machine)
      (-filter (lambda (button) (--every (< 0 (nth it (car machine))) button)) (cdr machine)))

    (defun or-min (l)
      (when l (-min l)))

    (defun nil-1+ (l)
      (when l (1+ l)))

    (defun solve-machine (machine)
      (when machine
        (if (= 0 (-sum (car machine))) 0
  	(nil-1+ (solve-machine (-first 'solve-machine (--map (cons it (cdr machine)) (--map (apply-button (car machine) it) (good-buttons machine)))))))))

    (memoize 'solve-machine)
  (let ((a))
  (setq num 0
  	res nil)
  (--each machines (progn (message (format "%d" (setq num (1+ num))))
  			(push (solve-machine it) res)))
  (-sum res))

  (cadr machines)
  (solve-machine (cadr machines))
  (length machines)151
#+end_src

#+RESULTS:
: 33