Можно в строку вывести что тебе нужно а потом вот этим пройтись

Можно попробовать использовать backtick и clojure.pprint.

Что-то наподобие,
(let [x 1]
 (with-out-str
   (clojure.pprint/pprint `(list 1 2 ~x))))

Ещё можно попробовать вот эту функцию, если нужно сохранить так, как ввели - https://clojuredocs.org/clojure.pprint/cl-format

супер, спасибо за советы!

ещё есть просто clojure.string/replace 😊

t k n r1 r2 = go [([], r1, r2)] where
  go l | null rs = go $ l >>= f
       | otherwise = rs where
    rs = filter (\(cs, r1, r2) -> r1 == n || r2 == n) l
  f (cs, r1, r2) = [("c1":cs, k*r2 - r1, r2), ("c2":cs, r1, k*r1 + r2)]

main = print $ t 1 100 1 5 

у меня вот такое получилось, куда mapcat засунуть — не придумал

(let [k 1 r1 1 r2 2 n 5
        c1 (fn [r1 r2] (- (* k r2) r1))
        c2 (fn [r1 r2] (+ (* k r1) r2))]
    (->> (iterate (fn [xs] (reduce (fn [xs, [[_ r1 r2] :as x]]
                                     (conj xs
                                       (conj x [:c1 (c1 r1 r2) r2])
                                       (conj x [:c2 r1 (c2 r1 r2)])))
                             [] xs))
           [(list [:c0 r1 r2])])
      (take 5)
      (reduce (fn [_ xs] (when-some [found (->> xs
                                             (filter (fn [[[_ r1 r2]]] (or (= r1 n) (= r2 n))))
                                             (seq))]
                           (reduced found))))))
=> (([:c2 2 5] [:c1 2 3] [:c2 1 3] [:c0 1 2]) ([:c2 1 5] [:c2 1 4] [:c2 1 3] [:c0 1 2]))

Если писать по другому алгоритму, то мапкат может оказаться и не нужен, конечно.

(defn t [k n r1 r2]
  (let [step (fn [[cs r1 r2]] [[(conj cs "c1") (- (* k r2) r1) r2]
                               [(conj cs "c2") r1 (+ (* k r1) r2)]])
        go (fn [l] (let [rs (filter (fn [[_ r1 r2]] (or (= n r1) (= n r2))) l)]
                     (if-not (empty? rs) rs (recur (mapcat step l)))))]
    (go [[[] r1 r2]])))

(prn (t 1 5 1 2))

(defn t [k n r1 r2]
  (let [step (fn [[cs r1 r2]] [[(conj cs "c1") (- (* k r2) r1) r2]
                               [(conj cs "c2") r1 (+ (* k r1) r2)]])
        go (fn [l] (let [rs (filter (fn [[_ r1 r2]] (or (= n r1) (= n r2))) l)]
                     (if-not (empty? rs) rs (recur (mapcat step l)))))]
    (go [[[] r1 r2]])))

(prn (t 1 5 1 2))

спасибо

(собственно, это хаскелькот выше, переписанный один в один на кложу 😁)

я догадался
к сожалению прочитать того кота я не смог 😊

(defn t [k n r1 r2]
  (let [step (fn [[cs r1 r2]] [[(conj cs "c1") (- (* k r2) r1) r2]
                               [(conj cs "c2") r1 (+ (* k r1) r2)]])
        go (fn [l] (let [rs (filter (fn [[_ r1 r2]] (or (= n r1) (= n r2))) l)]
                     (if-not (empty? rs) rs (recur (mapcat step l)))))]
    (go [[[] r1 r2]])))

(prn (t 1 5 1 2))

if-not empty это if seq

пардон, у меня на это триггер

В (mapcat step l) заключена вся магия - если у нас из каждого состояния есть варианты получить несколько (от 0 до любого конечного числа) других состояний, мы мапим список наших текущих состояний по этому ядру, получаем список списков состояний следующего шага, и конкатим его в линию, имея линейный список следующих состояний. Дальше можно проверять его на получение результата, фильтровать невозожные состояния и дубли, и т.п., но суть в этом. Другими словами, вот он обход графа состояний в ширину. А в терминах простых классов типов это обычный листомонадский бинт 😁

ну тогда там выше let на if-some менять

ну яж пытался сохранить аутентичность хаскелькота. так то можно было if some? написать

а ссылку можно на расшифровку «обычный листомонадский бинт»?

вроде нельзя, filter вернет пустую коллекцию?