452 PurelyFunctional.tv Newsletter

00 Consecutive numbers.md

Consecutive numbers

Write a function that determines whether a sequence of integers can be rearranged into a sequence of consecutive numbers without duplicates. The function should return the sequence of consecutive numbers or nil if it is not possible.

Examples

(consec []) ;=> () ;; trivially true
(consec [1]) ;=> (1) ;; ditto
(consec [3 1 2]) ;=> (1 2 3)
(consec [5 3 2 1]) ;=> nil ;; non-consecutive (4 is missing)
(consec [7 8 9 7]) ;=> nil ;; 7 repeats

Thanks to this site for the problem idea, where it is rated Hard in Java. The problem has been modified.

Please submit your solutions as comments on this gist.

To subscribe: https://purelyfunctional.tv/newsletter/

(defn consec [coll]
  (let [sorted (sort coll)
        pairs (partition 2 1 sorted)]
    (if (every? (fn [[a b]] (= b (inc a))) pairs)
      sorted)))

(defn consec
  "If its argument can be sorted into a sequence of consecutive integers
  without duplicates, return the sorted list, or nil if it cannot."
  [s]
  (let [sorted (sort s)]
    (when (every? #{-1} (map (partial apply -) (partition 2 1 sorted)))
      sorted)))

(defn consec [xs]
  (let [sorted-xs (sort xs)
        needed-xs (take (count xs)
                        (iterate inc (first sorted-xs)))]
    (when (= sorted-xs needed-xs)
      sorted-xs)))

(defn consec
  "function that determines whether a sequence of integers
  can be rearranged into a sequence of consecutive numbers
  without duplicates."
  [vect]
  (if (< (count vect) 2)
    vect    
    (let [unique-vect (into #{} vect)
          sorted-vect (sort vect)
          step-check (loop [[val1 val2 & rest] sorted-vect]
                       (let [diff (- val2 val1)]
                         (cond 
                           (and (nil? rest) (= diff 1)) true
                           (= diff 1) (recur (cons val2 rest))
                           :else nil)))]
    (if (and
          (= (count vect) (count unique-vect))
          step-check)
      sorted-vect
      nil))))

(defn consec [xs]
  (let [sxs (sort xs)]
    (when-not 
        (->> sxs (partition 2 1)
             (reduce (fn [misfit? [x y]]
                       (if misfit? 
                         (reduced true)
                         (not= 1 (- y x))))
                     false))
      sxs)))