Shuffling algorithms by a Clojure Novice

Question

The shuffle descriptions can be seen here... Shuffling

Am I using Clojure idioms and going with the grain of the language?

A few things that concern me..

• Am I doing too much logic in my let bindings? is this ok?
• Any obvious performance concerns with any of this? ways to improve it?

The Code

(ns card-shuffle)

(defn riffle
  ([cards] (riffle cards 1))
  ([cards times]
    (let [card_count (count cards)
          marg (if (> card_count 20) (int (* 0.1 card_count)) 2)
          middleish (+ (int (/ card_count 2)) (rand-nth (range (- marg) marg)))
          decks (split-at middleish cards)
          deck1 (->> (nth decks 0) (partition-by (fn [i] (= 0 (rand-int 2)))))
          deck2 (->> (nth decks 1) (partition-by (fn [i] (= 0 (rand-int 2)))))]
      (->> (interleave deck1 deck2) flatten))))

(defn overhand
  ([cards] (overhand cards 1))
  ([cards times]
    (let [card_count (count cards)
          shuffled_deck (->> cards
            (partition-by (fn [c] (= 0 (rand-int 2) )))
            reverse
            flatten)]
    (if (> times 1)
        (overhand shuffled_deck (dec times))
        shuffled_deck))))

(defn mongean
  ([cards] (mongean cards 1))
  ([cards times]
    (let [vec_cards (vec cards)
          num-cards (count vec_cards)
          final-order (concat (reverse (range 1 num-cards 2))
                              (range 0 num-cards 2))]
      (if (> times 1)
        (mongean (replace vec_cards final-order) (dec times))
        (seq (replace vec_cards final-order))))))

(defn pile
  ([cards] (pile cards 3 1))
  ([cards num_piles] (pile cards num_piles 1))
  ([cards num_piles times]
    (let [shuffled_cards (->>
            (range (dec num_piles) -1 -1)
            (mapcat #(take-nth num_piles (drop % cards)))
            reverse)]
      (if (> times 1)
        (pile shuffled_cards num_piles (dec times))
        shuffled_cards))))