ADVENT OF CODE
It's the holiday season! This year I'm trying my hand at a few
puzzles. I'm also giving away lots of holiday cards that I design and
printed myself (image below). All in all, it's a nice time of the year
to strive for a bit more challenge in my intellectual pursuits, and
happiness in my friendships.
(IMG) iillustration-11.png
Day 1
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
What I learned: getting the line count of a file and storing it in a
variable doesn't work. It seems that a separate shell process a is
spawned from this assignment, and so the code will carry on with its
evaluation without waiting for the result. This was solved by moving
the process that reads the value into the `for' loop.
,----
| PWD=$PWD
| INPUT="data.txt"
| BUFFER_DIR="$PWD/buffer"
| # LINES=$(wc -l $INPUT | grep -Po "[0-9]*$") This dosn't work
| rm count.temp
| wc -l $INPUT | grep -Po "[0-9]*" >> count.temp
|
| rm -r $BUFFER_DIR
| mkdir $BUFFER_DIR
|
| INDEX=0
| CALS_FOR_THIS_ELF=0
| # Need to count lines inside this statement, otherwise it don't work!
| for (( INDEX=0; INDEX < $(cat count.temp); INDEX++)); do
| ITEM_CALS=$(tail -n $INDEX $INPUT | head -n 1)
| IS_EMPTY_LINE=$(echo $ITEM_CALS | grep -Pc "^[[:space:]]*$")
|
| if [[ IS_EMPTY_LINE -gt 0 ]]; then
| touch "$BUFFER_DIR/$CALS_FOR_THIS_ELF"
| CALS_FOR_THIS_ELF=0
| fi
|
| CALS_FOR_THIS_ELF=$(( CALS_FOR_THIS_ELF + ITEM_CALS ))
| done
|
| cd $BUFFER_DIR
| ls -1 * | sort -Vr | head -n 3
| cd $PWD
`----
(IMG) iadvent-of-code-2.png
Day 2
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
I wanted something easy for my second day doing the Advent of Code, so
I settled on using Lua.
,----
| local SCORE_TABLE = {
| X = 1,
| Y = 2,
| Z = 3
| }
|
| local WIN_TABLE = {
| A = "Z", -- Rock beats sissors
| B = "X", -- Paper beats rock
| C = "Y" -- Sissors beats paper
| }
|
| local DRAW_TABLE = {
| A = "X",
| B = "Y",
| C = "Z",
| }
|
| function round_info(elf, me)
| local info
| info = {
| score = function()
| if info.drawer() then
| return 3 + SCORE_TABLE[me]
| elseif info.winner() then
| return 6 + SCORE_TABLE[me]
| else
| return SCORE_TABLE[me]
| end
| end,
| winner = function()
| return (WIN_TABLE[elf] ~= me)
| end,
| drawer = function()
| return (DRAW_TABLE[elf] == me)
| end,
| }
| return info
| end
|
| local read_file = function (path)
| local file = io.open(path, "rb")
| local rows = {}
| for col in io.lines(path) do
| local row = {}
| for x in col:gmatch("%w+") do
| table.insert(row, x)
| end
| table.insert(rows, round_info(row[1],row[2]))
| end
| file:close()
| return rows;
| end
|
| local my_score = 0
| for _, row in ipairs(read_file("data.txt")) do
| my_score = my_score + row.score()
| end
|
| print(my_score)
`----
Day 3
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
This was a great way for me to apply the LISP I've been reading.
I learned mostly about helpful string methods: splitting string,
converting a string to a char. Basic string stuff that's always good
to know in a language! I'm feeling more confident about EmacsLisp. The
use of recursion is delightful. Much more enjoyable than using a
loop. More powerful, too, I think, because the act of recursion,
paired with an accumulator, lets one dataset be built while another is
being deconstructed. Cool! I am a LISP gal now.
,----
| (setq max-specpdl-size 32000)
| (reduce #'+ (bagger (split-string (file-contents "./data.txt") "\n" t) (list)))
|
| (defun bagger(bag accumulator)
| (if (null bag)
| accumulator
| (let* ((contents (car bag))
| (len (cdr (read-from-string contents)))
| (front-compartment (substring contents 0 (/ len 2)))
| (back-compartment (substring contents (/ len 2) len)))
| (setq accumulator
| (append (list (char-to-priority (car (find-matching-chars front-compartment back-compartment)))) accumulator))
| (bagger (cdr bag) accumulator))))
|
| (defun char-to-priority (char)
| (let ((charnum (string-to-char char)))
| (if (s-uppercase-p char)
| (upper-char-to-priority charnum)
| (lower-char-to-priority charnum))))
|
| (defun upper-char-to-priority (char)
| (- char 38))
|
| (defun lower-char-to-priority (char)
| (- char 96))
|
| (defun find-matching-chars (stringa stringb)
| (let ((matched-chars "")
| (stringa (split-string stringa "\\|[a-zA-Z]+" t))
| (stringb (split-string stringb "\\|[a-zA-Z]+" t)))
| (split-string (mapconcat (lambda (x) (char-in-string x stringb)) stringa "")
| "\\|[a-zA-Z]+" t)))
|
| (defun char-in-string (char list)
| (cond ((null list) nil)
| ((string= char (car list)) char)
| (t (char-in-string char (cdr list)))))
|
| (defun file-contents (filename)
| (with-temp-buffer
| (insert-file-contents filename)
| (buffer-string)))
`----
Day 4
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
I really wanted to use regex for matching the data, but couldn't find
great documentation around moving through matched strings. So I used
the `split-string' function, as before, to parse each row of data into
the numbers I needed.
I also boxed myself into a corner by doing something weird early on:
converting the range from its boundaries (e.g: ("1" "6")) into a list
of each value therein (i.e.: (1 2 3 4 5 6)). Anyways, turns out it's
possible to check if one list of values is entirely contained within
another by comparing the length of the intersection with the length of
both lists.
,----
| (defun file-contents (filename)
| (with-temp-buffer
| (insert-file-contents filename)
| (buffer-string)))
|
| (defun int-range-to-list(start end accumulator)
| ;; given a range of numbers, produce a list
| (if (> start end)
| accumulator
| (setq accumulator (append (list start) accumulator))
| (int-range-to-list (+ 1 start) end accumulator)
| ))
|
| (defun unwrap-elves(elves)
| (mapcar (lambda (elf-pair)
| (let* ((cleaning-zones-boundaries (mapcar (lambda (elf)
| (split-string elf "-" t))
| (split-string elf-pair "," t)))
| (cleaning-zones-range (mapcar (lambda (zone)
| (int-range-to-list (string-to-number (car zone)) (string-to-number (cadr zone)) (list)))
| cleaning-zones-boundaries))
| (range-a (car cleaning-zones-range))
| (range-b (cadr cleaning-zones-range))
| (overlap (intersection range-a range-b))
| ;; part 1
| (is-contained (cond ((and (> (length overlap) 0)
| (or (= (length range-a) (length overlap))
| (= (length range-b) (length overlap)))) 1)
| (t 0)))
| ;; part 2
| (all-contained (cond ((> (length overlap) 0) 1)
| (t 0)))
| )
| all-contained
| )) elves))
|
| (reduce #'+(unwrap-elves (split-string (file-contents "./data.txt") "\n" t)))
`----
Day 5
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
Today was punishing. The input data included a visual representation
of a table that needed to be parsed for the letters it contained. The
letters needed to include column info, and this proved to be the most
challenging information to extract. I had to create a function
`translate' that took the location of the letter and translated that
number to a column value. It was a real pain in the butt.
This solution makes use of `with-temp-buffer' to store and parse the
data. In yesterday's question I struggled with understanding how to
use EmacsLisp's regexp faculties. Turns out, they're much easier to
use inside of a buffer. Consequently, much of my code includes
operations inside of a temp buffer.
Sample Data
----------------------------------------------------------------------
,----
| [D]
| [N] [C]
| [Z] [M] [P]
| 1 2 3
`----
Solution
----------------------------------------------------------------------
,----
| (setq stacks-count 9)
|
| (defun find-pattern-in-file (filename pattern point-transform)
| (with-temp-buffer
| (insert-file-contents filename)
| (setq case-fold-search nil) ;; might need to toggle via M-x toggle-case-fold-search
| (goto-char (point-min)) ;; We need to move to start of buffer
| (let* ((accumulator (list)))
| (while (re-search-forward pattern nil t)
| (setq accumulator (append accumulator (list (list (match-string 0)
| (funcall point-transform (- (match-beginning 0) (line-beginning-position))))))))
| accumulator)))
|
| (defun translate(p)
| (let ((col nil)
| (start 0)
| (end 0))
| (dotimes (i 9)
| (setq start (* i 4)) ;; 4 because '[N] ' contains 4 characters, and is considered one column.
| (setq end (+ (* i 4) 4))
| (cond ((not (eq nil col))
| col)
| ((and (>= p start)
| (<= p end))
| (setq col i))))
| col))
|
| (progn
| (let* ((boxes (find-pattern-in-file "./data.txt" "[A-Z]" #'(lambda(p)
| (+ (translate p) 1))))
| (movements-ungrouped (nthcdr 9 (find-pattern-in-file "./data.txt" "[0-9]+" #'(lambda(p) nil))))
| (movements-grouped (list)))
| (cl-do* ((i 0 (+ i 3)))
| ((>= i (length movements-ungrouped)))
| (let ((count (car (nth i movements-ungrouped)))
| (from (car (nth (+ i 1) movements-ungrouped)))
| (to (car (nth (+ i 2) movements-ungrouped))))
| (setq movements-grouped (append movements-grouped (list (list (string-to-number count) (string-to-number from) (string-to-number to)))))))
| (setq rearranged-boxes (with-temp-buffer
| (dotimes (i (+ 1 stacks-count))
| (insert "\n"))
| (cl-do* ((i (- (length boxes) 1) (- i 1)))
|
| j((< i 0))
| (let* ((box (car (nth i boxes)))
| (column (cadr (nth i boxes))))
| (goto-line column)
| (insert box)))
| (cl-do ((i 0 (+ i 1))) ((= i (length movements-grouped)))
| (let* ((m (nth i movements-grouped))
| (count (nth 0 m))
| (from (- (nth 1 m) 0))
| (to (- (nth 2 m) 0)))
| (goto-line from)
| (line-beginning-position)
| (let ((box (buffer-substring (point) (+ (point) count))))
| (goto-line to)
| (insert box)) ;; (insert (reverse box)) ;; for part 1 use reverse
| (goto-line from)
| (line-beginning-position)
| (delete-region (point) (+ (point) count))))
| (dotimes (i (+ 1 stacks-count))
| (goto-line i)
| (delete-region (+ (point) 1) (line-end-position)))
| (replace-string-in-region "\n" "")
| (buffer-string)))
| (mapconcat (lambda(s) s) (split-string rearranged-boxes "\n" t) "")))
`----
Day 6
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
I completed today's problem in about 30 minutes. I made use of some
new-to-me sequence functions like `seq-take' and `seq-uniq' to grab
and compare parts of lists.
,----
| (defun file-contents (filename)
| (with-temp-buffer
| (insert-file-contents filename)
| (buffer-string)))
|
| ;; Part 1
| (let ((message (split-string (file-contents "data.txt") "" t))
| (start nil))
| (dotimes (i (- (length message) 4))
| (let* ((maybe-header (seq-take (nthcdr i message) 4)))
| (cond ((and (eq nil start)
| (eq 4 (seq-length (seq-uniq maybe-header))))
| (setq start (+ 4 i))))))
| (print start))
|
| ;; Part 2
| (let ((message (split-string (file-contents "data.txt") "" t))
| (start nil)
| (m-start nil))
| (dotimes (i (- (length message) 4))
| (let* ((maybe-header (seq-take (nthcdr i message) 4)))
| (cond ((and (eq nil start)
| (eq 4 (seq-length (seq-uniq maybe-header))))
| (setq start (+ 4 i)))
| ((and (numberp start) (eq nil m-start))
| (let ((maybe-message (seq-take (nthcdr i message) 14)))
| (cond ((eq 14 (seq-length (seq-uniq maybe-message)))
| (setq m-start (+ 14 i))
| ))
| )))))
| (print m-start))
`----