Forma idiomática de iterar a través de todos los pares de una colección en Clojure

Question

Dada una colección, quiero iterar a través de todos los pares en una colección. Ejemplo

(all-pairs seq) 

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

Aquí está mi idea

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

Pero no se siente idiomática

Answer 1

¿Qué tal:

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

Answer 2

puedo sugerir:

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

EDIT: Es evidente que leí mal la pregunta; ya que solo desea pares distintos no duplicados, aún podemos usar este enfoque si existe un orden natural en cualquier dominio al que llame esta función.

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

EDITAR 2

también:

(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 3

perezoso, y relativamente rápido.

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

---

(defn all-pairs [coll] 
    (let [x (first coll) xs (next coll)] 
    (when xs 
     (lazy-cat 
     (map (fn [y] [x y]) xs) 
     (all-pairs xs))))) 

---

(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])

Answer 4

Una versión recursiva simple que debe hacer lo que quiera:

(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 5

No es la solución más rápida, pero:

; 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)))) 

Answer 6

(defn all-pairs [coll] 
    (loop [[x & xs] coll 
     result []] 
    (if (nil? xs) 
     result 
     (recur xs (concat result (map #(vector x %) xs)))))) 

Answer 7

¿Qué tal esto?

(defn all-pairs [coll] 
(when coll 
    (concat (map vector (repeat (first coll)) (rest coll)) 
      (all-pairs (next coll))))) 

O, si usted busca un vago siguientes:

(defn all-pairs [coll] 
(lazy-seq 
    (when coll 
    (concat (map vector (repeat (first coll)) (rest coll)) 
      (all-pairs (next coll)))))) 

Answer 8

¿Y esto?

(defn seq->pairs 
    [s] 
    (loop [res [] s s] 
    (let [[head next] (split-at 2 s) 
      res (conj res head)] 
     (if (empty? next) res (recur res next))))) 

Answer 9

Sólo otra solución posible:

(defn all-pairs 
     [c] 
     (mapcat #(drop % %2) 
       (range 1 (count c)) 
       (partition (count c) (for [a c b c] [a b])))) 


(all-pairs '(a b c d)) => ([a b] [a c] [a d] [b c] [b d] [c d])) 
(all-pairs [5 4 3 2 1]) => ([5 4] [5 3] [5 2] [5 1] [4 3] [4 2] [4 1] [3 2] [3 1] [2 1]) 
(all-pairs "pairs") => ([\p \a] [\p \i] [\p \r] [\p \s] [\a \i] [\a \r] [\a \s] [\i \r] [\i \s] [\r \s]) 

Answer 10

Si desea escribir su propia combinations función en "estilo académico," se puede tratar

(defn comb [xs m] 
    (cond 
    (= m 0) (list()) 
    (empty? (seq xs))() 
    :else (let [x (first xs) 
       xs (rest xs)] 
      (concat 
      (map #(cons x %) (comb xs (- m 1))) 
      (comb xs m))))) 

y luego aplicarlo a su problema de la siguiente manera

(map vec (comb '(a b c d) 2)) 

([a b] [a c] [a d] [b c] [b d] [c d])