https://projecteuler.net/problem=78

euler.clj

(ns com.github.hindol.euler
  (:require
   [clojure.test :refer [is]]
   [clojure.tools.trace :refer [trace-ns untrace-ns]])
  (:gen-class))

(set! *unchecked-math* true)
(set! *warn-on-reflection* true)

(defn pentagonal-seq
  []
  (let [xf (comp
            (mapcat (juxt identity -))
            (map #(/ (* % (dec (* 3 %))) 2)))] ;; k (3k - 1) / 2
    (sequence xf (iterate inc 1))))

(def cached-pentagonal-seq
  (pentagonal-seq))

;; https://projecteuler.net/problem=78
;;
;; *
;;
;; **
;; * *
;;
;; ***
;; ** *
;; * * *
;;
;; ****
;; *** *
;; ** **
;; ** * *
(def count-partitions
  "Given n coins, how many distinct partitions are possible?"
  (memoize
   (fn
     [n]
     {:pre  [(is (not (neg? n)))]
      :post [(is (not (neg? %)))]}
     (cond
       (neg? n)  0
       (zero? n) 1
       :else     (let [xf    (comp
                              (take-while #(<= % n))
                              (map #(count-partitions (- n %))))
                       terms (sequence xf cached-pentagonal-seq)
                       signs (cycle [+1 +1 -1 -1])]
                   (reduce +' (map * signs terms)))))))

(defn -main
  [& _]
  (let [n  6
        xf (comp
            (map count-partitions)
            (take-while #(pos? (rem % 1000000))))]
    (+ n (count (sequence xf (iterate inc n))))))

(time (-main))

For posterity, here it is with the transducer:
Takes 4.2s on my machine.

(set! *unchecked-math* true)

(def ^:const modulo
  1000000)

(def ^:const limit
  100000)

(defn solve []
  (loop [n 1 partitions (vector-of :long 1)]
    (if (<= n limit)
      (let [sum (unchecked-long
                  (loop [sum 0 i 0 offsets (sequence (comp (mapcat (juxt identity -))
                                                           (map (fn [^long %] (quot (* % (dec (* 3 %))) 2))))
                                                     (iterate inc 1))]
                    (let [offset (unchecked-long (first offsets))]
                      (if (< n offset)
                        sum
                        (if (< (rem i 4) 2)
                          (recur (rem (+ sum (unchecked-long (nth partitions (- n offset)))) modulo) (inc i) (rest offsets))
                          (recur (rem (- sum (unchecked-long (nth partitions (- n offset)))) modulo) (inc i) (rest offsets)))))))
            sum (if (neg? sum) (+ sum modulo) sum)]
        (if (zero? sum)
          (count partitions)
          (recur (inc n) (conj partitions sum))))
      (count partitions))))

(time (solve))