136 lines
4.0 KiB
Common Lisp
136 lines
4.0 KiB
Common Lisp
;; // https://adventofcode.com/2022/day/21
|
|
;; well, this seems like this could be done with (eval)
|
|
;; would it be possible for me to also translate
|
|
;; xxx + yyy into (call xxx) + (call yyy)
|
|
;; that would be neat
|
|
|
|
(in-package :day-21)
|
|
|
|
;; so. have mashmap from symbol name into operation
|
|
;; and have (my-eval)?
|
|
;; it will take symbol name, and either return number directly from the map
|
|
;; or will wrap the names into my-eval and run operation on them?
|
|
|
|
;; is there a way to have less code and reuse existing lisp things?
|
|
;; if there's direct number, i could just run (defparameter lfqf 4)
|
|
;; and then execute root directly, i think
|
|
;; or what, i'd need to also define all the intermediate symbols,
|
|
;; (setq a (+ c d)) ; complains that C is unbound
|
|
;; how could this be a lazy eval?
|
|
;; well. hm
|
|
;; i could define all of these as macroses?
|
|
(defmacro *test-monkey-hmdt* () 32)
|
|
(+ 3 (*test-monkey-hmdt*))
|
|
|
|
;; yup, i guess
|
|
|
|
(defparameter *test-monkey-sllz* 4)
|
|
(eval *test-monkey-sllz*)
|
|
(defparameter *test-monkey-ljgn* 2)
|
|
(defparameter *my-operation* '(+ *test-monkey-sllz* *test-monkey-ljgn*))
|
|
*my-operation*
|
|
(eval *my-operation*) ; well, that works ok
|
|
;; so, read all of these things as parameters.
|
|
|
|
;; "root: pppw + sjmn "
|
|
|
|
(mapcar #'intern (ppcre:split " " "root: pppw + sjmn "))
|
|
(mapcar #'parse-integer-or-symbol (ppcre:split " " "root: 44"))
|
|
|
|
(ppcre:regex-replace ":" "root: pppw + sjmn " "")
|
|
|
|
(line-to-quoted-operation "root: pppw + sjmn")
|
|
(eval (line-to-quoted-operation "dbpl: 5"))
|
|
|
|
;; well, i'd want to put quoted expression into parameter?
|
|
;; and now i can remove quoting of the defparameter?
|
|
;; and actually define all of the parameters?
|
|
|
|
(loop
|
|
for line in (uiop:read-file-lines "day21-test.txt")
|
|
for definition = (line-to-quoted-operation line)
|
|
do (eval definition))
|
|
|
|
(eval root)
|
|
|
|
;; (load-file-defs "day21-test.txt")
|
|
;; (eval root)
|
|
|
|
;; (load-file-defs "day21-input.txt")
|
|
;; (print (eval root))
|
|
|
|
;; now. things are different.
|
|
;; HUMN is my input
|
|
;; and ROOT is "comparison of two numbers"
|
|
;; and change in root can influence results in a significant way
|
|
;; so, how'd i do that?
|
|
;;
|
|
;; what could be done then?
|
|
;; i could potentially somehow modify the operations?
|
|
;; so that (eval humn) would return
|
|
;;
|
|
;; root: pppw + sjmn
|
|
;; so. root should mean
|
|
;; pppw == sjmn
|
|
;; don't know which has HUMN yet.
|
|
;; should i then just eval those that have HUMN into a operation?
|
|
;; and others into a number?
|
|
;; well, i suppose i'd need to do pass down somehow
|
|
;; eval both parts of the root.
|
|
;; and then what?
|
|
;;
|
|
;; let's skip for now?
|
|
|
|
;; or, alternatively. i could save HUMN num disregard
|
|
;; defparameter with HUMN to be used as HUMN =
|
|
;; and then what? root
|
|
;; but then i'd need to reverse all the other operations, hm
|
|
;; or, maybe i could join into flat expression?
|
|
;; and then what? i macroexpand?
|
|
;;
|
|
;; now. i had an idea. i could have additional symbols,
|
|
;; also pointing to quoted computations
|
|
;; but these would be `back-ptdq`
|
|
;; for line 'lgvd: ljgn * ptdq'
|
|
;; make two? for each
|
|
;;
|
|
;; ptdq: humn - dvpt
|
|
;; back-humn = ptdq + dvpt
|
|
;; but one of these wouldn't be possible to forward eval, so it would be back-ptdq + dvpt
|
|
;; and on
|
|
;; root: pppw + sjmn
|
|
;; two would be created back-pppw = - eval sjmn and vice versa
|
|
;; this should work?
|
|
|
|
;; sure, let's try?
|
|
;; so we'd do what?
|
|
;; same for forward eval?
|
|
;; and two for back-monkey
|
|
|
|
(back-symbol 'hello)
|
|
|
|
|
|
(intern (format nil "BACK-~a" 'yo))
|
|
;; and i need reverse of the operands?
|
|
|
|
(reverse-operation '+)
|
|
(line-to-quoted-operation-2 "dbpl: 5")
|
|
(line-to-quoted-operation-2 "pppw: cczh / lfqf")
|
|
(line-to-quoted-operation-2 "lgvd: ljgn * ptdq")
|
|
(line-to-quoted-operation-2 "drzm: hmdt - zczc")
|
|
(line-to-quoted-operation-2 "cczh: sllz + lgvd")
|
|
(line-to-quoted-operation-2 "root: pppw + sjmn")
|
|
|
|
|
|
;; i think it's done? let's try to eval all of this?
|
|
;; but i also need root back-computation.
|
|
;; for each operant that they are equal to forward calculation of another
|
|
|
|
;; (load-file-defs-2 "day21-test.txt")
|
|
;; (eval root)
|
|
;; (eval back-humn) ; 301. cool
|
|
|
|
;; (load-file-defs-2 "day21-input.txt")
|
|
;; (print (eval back-humn))
|
|
;; 3715799488132
|