What we worked on Wednesday

diffs.clj

(ns ssiMaps.arrays)

; yuck – a for loop 
'(1 2 3 4 5)
'((1 2) (2 3) (3 4) (4 5))
'(1 1 1 1)
(defn diffs-map [values]
  (let [sorted-values (sort values)]
    (loop [values sorted-values
           differences []]
      (if (= 1 (count values))
        differences
        (let [x (first values)
              rest-values (rest values)
              y (first rest-values)
              diff (Math/abs (- x y))]
          (recur rest-values (cons {:pair (list x y) :diff diff} differences)))))))

; somewhat better I think? at least the yuck is hidden away from this function 
(defn min-diff [values]
  (let [diffs-map  (diffs-map values)
        min-value  (apply min (map #(:diff %) diffs-map))
        min-values (filter #(= min-value (:diff %)) diffs-map)]
    (->> (map #(:pair %) min-values)
         (reduce into)
         (sort)
         (clojure.string/join " "))))


(defn pairs [v]
  (map-indexed
    (fn [index item]
      [(nth v index) item])
    (drop 1 v)))

(defn diffs [pairs] 
  (map #(Math/abs (- (first %) (second %))) pairs))

(prn (drop 1 [1 2 3 4 5]))
(prn (nth [1 2 3 4 5] 0))
(prn (pairs [1 2 3 4 5]))
(prn (diffs [[1 2] [2 3] [3 4] [4 5]]))
(prn (-> [1 2 3 4 5]
         (pairs)
         (diffs)))

(prn (diffs-map [1]))
(prn (diffs-map [1 2]))
(prn (diffs-map [1 2 3 4]))


(prn (= "2 3 3 4 4 5" (min-diff [5 4 3 2])))
(prn (= "-520 -470 -20 30" (min-diff [-20 -3916237 -357920 -3620601 7374819 -7330761 30 6246457 -6461594 266854 -520 -470])))