Most simple form of string compression.

compression.clj

(defn string-compression
  "Compresses a string by appending the count after the repeat of each
  letter. For example: \"aabccccaaa\" would become \"a2b1c4a3\".

  If the compressed string is larger than the original, it should return the
  original."
  [s]
  (let [cnt-orig (count s)
        compress-fn (fn [coll c]
                      (if (empty? coll)
                        [c 1]
                        (let [last-char (first (take-last 2 coll))
                              last-count (last coll)]
                          (if (= last-char c)
                            (conj (into [] (butlast coll)) (inc last-count))
                            (conj coll c 1)))))
        compressed (str/join (reduce compress-fn [] s))]
    (if (> (count compressed) (count s))
      s
      compressed)))

(fn [in] (min-key count in (reduce #(str %1 (first %2) (count %2))  "" (partition-by identity in))))

Test cases:

((fn [in] (min-key count in (reduce #(str %1 (first %2) (count %2))  "" (partition-by identity in))))  "abcdef")
=> "abcdef"

((fn [in] (min-key count in (reduce #(str %1 (first %2) (count %2))  "" (partition-by identity in))))  "aabccccaaa")
=> "a2b1c4a3"