Idomatic way to iterate through all pairs of a collection in Clojure

Question

Given a collection I want to iterate through all paris in a collection. Example

(all-pairs seq)

(all-pairs '(a b c d)) => ([a b] [a c] [a d] [b c] [b d] [c d]))

Here is my idea

(defn all-pairs [coll]
  (for [ [idx elmt] (indexed coll)
         other-elmt (subvec coll (inc idx))]
     (vector elmt other-elm)))

But it doesn't feel idiomatic

Answer 1

May I suggest:

(defn all-pairs [sq] (for [i sq j sq] [i j]))

EDIT: Clearly I misread the question; since you only want distinct unduplicated pairs, we can still use this approach if a natural ordering exists on whatever domain you're calling this function on.

(defn all-pairs [sq] (filter #(< (first %) (second %)) (for [i sq j sq] [i j])))

EDIT 2

Also:

(defn all-pairs [sq]
    (partition 2 (flatten (map (fn [sqi] (map #(vector %1 %2) sq sqi))
                   (take-while not-empty (iterate rest (rest sq)))))))

Answer 2

[initial attempt - overly complex]

(use '[clojure.contrib.seq :only [indexed]])

(defn all-pairs [coll]
  (for [[index i] (indexed coll) j (drop (inc index) coll)]
    [i j]))

Concerning idiom, I don't know how well I'd rank this. It could be faster too, but probably at the expense of brevity.

__

The following is much better:

(defn all-pairs [coll]
  (when-let [s (next coll)]
    (lazy-cat (for [y s] [(first coll) y])
              (all-pairs s))))

(all-pairs [1 2 3 4]) ;; => ([1 2] [1 3] [1 4] [2 3] [2 4] [3 4])

(all-pairs '(a b c d)) ;; => ([a b] [a c] [a d] [b c] [b d] [c d])

https://gist.github.com/ae0d9ebf85e9ba6e2cb3

Answer 3

A simple recursive version that should do what you want:

(defn all-pairs [coll]
  (let [x (first coll)
        xs (rest coll)]
    (if (empty? xs) 
      nil
      (concat 
        (map (fn [y] [x y]) xs) 
        (all-pairs xs)))))

Answer 4

How about:

(use 'clojure.contrib.combinatorics)
(vec (map vec (combinations '(a b c d) 2)))

Answer 5

Not the fastest solution, but:

; handy helper function
(defn tails [v]
  "Given a sequence ( a b c ), returns all tails:  ( a b c ) ( b c ) ( c )"
  (when (seq v) 
    (lazy-cat (list v) (tails (rest v)))))

(defn pair* [v]
  "Match the first item in the list with all others in pairs."
  (when (> (count v) 1)
    (for [y v] [(first v) y])))

(defn all-pairs [v]
  (apply concat (map pair* (tails v))))