Question

I need to traverse a list and do some calculations with every element and the elements excluding that element. For example, having a list (1 2 3 1), I need pairs (1) (2 3 1), (2) (1 3 1), (3) (1 2 1) and (1) (2 3 1).

Answer 1

(…) with every element and the elements excluding that element.

With every element sounds like a map. Excluding that element sounds like a filter. Let’s start with the latter.

user=> (filter #(not= % 1) '(1 2 3))
(2 3)

Great. Now let’s try to map it over all elements.

user=> (let [coll '(1 2 3)] (map (fn [elem] (filter #(not= % elem) coll)) coll))
((2 3) (1 3) (1 2))

Creating actual pairs is left as an exercise for the reader. Hint: modify the closure used in map.

Keep in mind that the solution suggested above should work fine for short lists but it has a complexity of O(n²). Another issue is the fact that collections with duplicates aren’t handled correctly.

Let’s take a recursive approach instead. We’ll base the recursion on loop and recur.

(defn pairs [coll]
  (loop [ahead coll behind [] answer []]
    (if (empty? ahead)
      answer
      (let [[current & remaining] ahead]
        (recur remaining
               (conj behind current)
               (conj answer [(list current)
                             (concat behind remaining)]))))))

A trivial example:

user=> (pairs '(1 2 3))
[[(1) (2 3)] [(2) (1 3)] [(3) (1 2)]]

A vector with duplicates:

user=> (pairs [1 5 6 5])
[[(1) (5 6 5)] [(5) (1 6 5)] [(6) (1 5 5)] [(5) (1 5 6)]]