How to iterate through a vector of vectors? - loops

Question

I have a data structure like this:
(defparameter *test*
#(#(3)
#(7 4)
#(2 4 6)
#(8 5 9 3)))
which represents a triangle of integers and a function
(defun get-node (i j triangle)
"Returns the value of the node I J of TRIANGLE."
(assert (<= j i) (i j) "~&J has to be smaller than I! I: ~D J: ~D~%" i j)
(svref (svref triangle i) j))
which allows me to access each node of the triangle easily (at least I think it does).
I thought using these two it would be easy to build up the sum along different paths through the triangle from top (3) to bottom, e.g. 8 --> 3 + 7 + 2 + 8 = 20. The next path would be 3 + 7 + 2 + 5 = 17.
Unfortunately, I totally fail to generate the indices of my vector of vectors in a reasonable way to find all the eight path in this simple example. This is not about brute-force vs. dynamic programming, etc. I am just looking for a way to iterate through the columns and rows of *test* which assures that each path was found.
How could one iterate the two indices, e.g. i and j in such a way that the correct combinations are found?

Answer 1

I think i now better understand what you want to enumerate so here is
another answer to your question for the alternative definition of
a “path”: a path can be described as a sequence of directions,
either down (0) or down right (1). That is trivially mapped
to an unsigned integer 0 ≤ path < 2path-directions
where each bit represents the successive directions. Each path is
conveniently represented by the pair (path-directions, number)
where path-directions is the number of directions, and number
encodes the successive directions in bits 0 through path-directions-1.
(defun gen-paths (path-directions)
(loop for i below (expt 2 path-directions)
collect i))
(gen-paths 3) => (0 1 2 3 4 5 6 7)
(defun path-to-directions (path-directions path)
(loop for i downfrom (- path-directions 1) to 0
collect (elt #(:down :down-right)
(ldb (byte 1 i) path))))
(loop for path in (gen-paths 3) collect (path-to-directions 3 path)) =>
((:DOWN :DOWN :DOWN) (:DOWN :DOWN :DOWN-RIGHT)
(:DOWN :DOWN-RIGHT :DOWN) (:DOWN :DOWN-RIGHT :DOWN-RIGHT)
(:DOWN-RIGHT :DOWN :DOWN) (:DOWN-RIGHT :DOWN :DOWN-RIGHT)
(:DOWN-RIGHT :DOWN-RIGHT :DOWN) (:DOWN-RIGHT :DOWN-RIGHT :DOWN-RIGHT))
Note that path-directions is one less than the size of the
triangle. When you represent the path as the list of nodes you
have an extra element, the starting node (0, 0).
(defun path-to-ref (path-directions path)
"Map a path to the list of (I J) pairs as understood by `get-node`."
(loop for i upto path-directions
for j = 0 then (+ j (ldb (byte 1 (- path-directions i)) path))
collect (list i j)))
 
(loop with path-directions = (- (length *test*) 1)
for path in (gen-paths path-directions)
collect (path-to-ref path-directions path))
=>
(((0 0) (1 0) (2 0) (3 0)) ((0 0) (1 0) (2 0) (3 1))
((0 0) (1 0) (2 1) (3 1)) ((0 0) (1 0) (2 1) (3 2))
((0 0) (1 1) (2 1) (3 1)) ((0 0) (1 1) (2 1) (3 2))
((0 0) (1 1) (2 2) (3 2)) ((0 0) (1 1) (2 2) (3 3)))
 
(defun get-path-nodes (path triangle)
"Returns the values of the nodes along PATH in TRIANGLE"
(loop with path-directions = (- (length triangle) 1)
for (i j) in (path-to-ref path-directions path)
collect (get-node i j triangle)))
You can then easily get the values:
(loop with path-directions = (- (length *test*) 1)
for path in (gen-paths path-directions)
collect (get-path-nodes path *test*))
=>
((3 7 2 8) (3 7 2 5) (3 7 4 5) (3 7 4 9)
(3 4 4 5) (3 4 4 9) (3 4 6 9) (3 4 6 3))
or sum them
(loop with path-directions = (- (length *test*) 1)
for path in (gen-paths path-directions)
collect (loop for v in (get-path-nodes path *test*)
sum v))
=>
(20 17 19 23 16 20 22 16)

Answer 2

Lisp unsurprisingly has friendlier support for lists, so I went with:
(defparameter *pyre*
'((3)
(7 4)
(2 4 6)
(8 5 9 3)))
My first stab just collects a tree and is repetitive but perhaps easier to follow:
(defun summit (n levels)
(destructuring-bind (this . more) levels
(let ((me (nth n this)))
(if more
(list
(list* me (summit n more))
(list* me (summit (1+ n) more)))
(list me)))))
Test by evaluating:
(summit 0 *pyre*)
Now tighten it up and compute the sums:
(defun summit (n levels)
(destructuring-bind (this . more) levels
(let ((me (nth n this)))
(if more
(loop for fork below 2
nconc (summit (+ n fork) more) into fork-sums
finally (return (loop for fs in fork-sums
collecting (+ me fs))))
(list me)))))
If recomputing paths concerns you, we could have some fun and rplaca the cons at one level with the sum of the existing car and each value computed at the next level. Left as an exercise.
Addendum: OK, no need for rplaca to avoid repeated calculations, to my great disappointment (but the moral is that recursion makes explicit path management unnecessary by funneling data along the paths implicit in the data):
(defun summit-ex (levels)
(destructuring-bind (level . lower-levels) levels
(if lower-levels
(loop with next-result = (let ((nr (summit-ex lower-levels)))
(print nr)
nr)
for pos upfrom 0
for value in level
for next-values = (loop for fork below 2
append (nth (+ pos fork) next-result))
collect (loop for next-value in next-values
collecting (+ value next-value)))
(mapcar 'list level))))
The debug printing was left in place because I like how they make clear what is going on:
((8) (5) (9) (3))
((10 7) (9 13) (15 9))
((17 14 16 20) (13 17 19 13))
((20 17 19 23 16 20 22 16))
Meanwhile, yes, some languages are more vector-friendly, such as Clojure:
(def pyre [[3]
[7 4]
[2 4 6]
[8 5 9 3]])
(defn summit-ex [[level & lower-levels]]
(if lower-levels
(let [next-result (summit-ex lower-levels)]
(for [pos (range (count level))]
(let [value (nth level pos)
next-values (mapcat #(nth next-result (+ pos %))
[0 1])]
(map #(+ value %) next-values))))
(map list level)))
Me, I prefer Lisp.

Answer 3

To generate the “paths”, that is the sequence of (i j)s you can do:
(defun gen-paths (depth)
(if (plusp depth)
(loop for p in (gen-paths (- depth 1))
nconc (loop for j to depth
collect (append p (list (list depth j)))))
'(((0 0)))))
For example (gen-paths 3) =>
(((0 0) (1 0) (2 0) (3 0)) ((0 0) (1 0) (2 0) (3 1)) ((0 0) (1 0) (2 0) (3 2)) ((0 0) (1 0) (2 0) (3 3))
((0 0) (1 0) (2 1) (3 0)) ((0 0) (1 0) (2 1) (3 1)) ((0 0) (1 0) (2 1) (3 2)) ((0 0) (1 0) (2 1) (3 3))
((0 0) (1 0) (2 2) (3 0)) ((0 0) (1 0) (2 2) (3 1)) ((0 0) (1 0) (2 2) (3 2)) ((0 0) (1 0) (2 2) (3 3))
((0 0) (1 1) (2 0) (3 0)) ((0 0) (1 1) (2 0) (3 1)) ((0 0) (1 1) (2 0) (3 2)) ((0 0) (1 1) (2 0) (3 3))
((0 0) (1 1) (2 1) (3 0)) ((0 0) (1 1) (2 1) (3 1)) ((0 0) (1 1) (2 1) (3 2)) ((0 0) (1 1) (2 1) (3 3))
((0 0) (1 1) (2 2) (3 0)) ((0 0) (1 1) (2 2) (3 1)) ((0 0) (1 1) (2 2) (3 2)) ((0 0) (1 1) (2 2) (3 3)))
You can then map get-node into this to transform these indexes into the corresponding values:
(loop for path in (gen-paths 3)
collect (loop for (i j) in path
collect (get-node i j *test*)))
=>
((3 7 2 8) (3 7 2 5) (3 7 2 9) (3 7 2 3)
(3 7 4 8) (3 7 4 5) (3 7 4 9) (3 7 4 3)
(3 7 6 8) (3 7 6 5) (3 7 6 9) (3 7 6 3)
(3 4 2 8) (3 4 2 5) (3 4 2 9) (3 4 2 3)
(3 4 4 8) (3 4 4 5) (3 4 4 9) (3 4 4 3)
(3 4 6 8) (3 4 6 5) (3 4 6 9) (3 4 6 3))
or sum the values of each “path”
(loop for path in (gen-paths 3)
collect (loop for (i j) in path
summing (get-node i j *test*)))
=>
(20 17 21 15 22 19 23 17 24 21 25 19 17 14 18 12 19 16 20 14 21 18 22 16)