The coin problem - as stated here: http://blog.jgc.org/2013/04/the-minimum-coin-problem-with-prize.html

maximum coins

(def coins [2 1 1 0.5 0.5 0.2 0.2 0.2 0.1 0.05 0.05 0.02 0.02 0.01 0.01])
 
(defn square [x]
  (* x x))
 
(defn distance
  [x y]
  (square (- x y)))
 
(defn fix-coin
  [i coins fixed]
  (let [coins (reverse (sort coins))]
    (loop [coins coins
           fixed fixed]
      (if (and (first coins) (> (first coins) i))
        (recur (rest coins) (conj fixed (first coins)))
        [coins, fixed]))))
    
(defn maximum-coins
  [sum coins]
  (let [sum (int (* 100 sum))]
    (loop [cns (map #(int (* 100 %)) coins)
           give '()]
      (let [s (apply + (concat cns give))
            d (- s sum)
            [cns give] (fix-coin d cns give)
            cns (sort #(compare (distance d %1) (distance d %2)) 
                       cns)]
        (if (> (count cns) 0)
              (recur (rest cns) give)
          (map #(float (/ % 100)) give))))))

The initial version was simpler - this works however....