Marketing Pitch and Impressions#

Common Lisp is intended to meet these goals:

  • Commonality
  • Portability
  • Consistency
  • Expressiveness
  • Compatibility
  • Efficiency
  • Power
  • Stability

— Common Lisp The Language 2e, Guy L. Steele Jr. (abridged)

I’ve included the list of design goals from the introduction of Common Lisp The Language, Second Edition. There is a greater explanation of each point in the introduction, spanning several pages which I did not want to reproduce here.

While the Lisp family of languages has been around since the mid 1950s, Common Lisp did not come into existence until the early to mid 1980s, making either this solution or the C++ one the oldest language I’ve used this year.

Visual Studio Code support is good. Lots of folks prefer to use Emacs.

The Code#

Lisp and even Common Lisp some decades later, must have been wildly beyond their time. The functional focus with multi-paradigm pragmatism seem very modern. As mentioned in the Racket solution, some find the parenthesis-heavy syntax difficult to scan easily, and I can see why.

Again I compute the required values for part 1 and 2 in the same loop. The loop takes a snapshot of the current state at the beginning, and then scans across the current line looking for splitters. For part 1 we just keep track of the number of times a beam hits a splitter. For part 2, we need the total number of splitter duplications that didn’t end up off the edges of the manifold.

This, to me at least, seems like a pragmatic mix of functional style-looping and shows how powerful the loop macro can be, combined with per-row stateful mutation that means the solution runs quite quickly.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

(defun read-lines (file)
  (with-open-file (s file)
    (loop for l = (read-line s nil) while l collect l)))

(let* ((lines (read-lines "y25d07.txt"))
       (counts (map 'vector (lambda (c) (if (char= c #\S) 1 0)) (first lines)))
       (n (length counts))
       (result1 0))
  (dolist (line (rest lines))
    (loop with snap = (copy-seq counts)
          for x below n for c across line
          when (and (char= c #\^) (plusp (aref snap x))) do
            (incf result1)
            (setf (aref counts x) 0)
            (when (plusp x) (incf (aref counts (1- x)) (aref snap x)))
            (when (< x (1- n)) (incf (aref counts (1+ x)) (aref snap x)))))
  (format t "Result1: ~A~%" result1)
  (format t "Result2: ~A~%" (reduce #'+ counts)))

Install SBCL and run#

SBCL seems to be the most widely supported open-source Common Lisp available, but others should work too.

# I installed via Homebrew
brew install sbcl

# Probably available in your package manager elsewhere
# sudo apt install sbcl

# Execute the code
sbcl --script d07.lsp