Posso "trasporre" un elenco di mappe in una mappa di elenchi in Clojure?

Question

Ciao huys: voglio mappare una "media" per tutti i valori in una mappa. dire che ho un elenco di mappe:

[{"age" 2 "height" 1 "weight" 10}, 
{"age" 4 "height" 4 "weight" 20}, 
{"age" 7 "height" 11 "weight" 40}] 

E il mio output desiderato è

{"age 5 "height" 5 ....} 

/// seguito sono elencate le divagazioni del mio cervello, vale a dire il modo in cui avrei potuto immaginare questo lavoro in Clojure .. .non essere preso troppo sul serio

recepire l'elenco:

{"age" [2 4 7] "height" [1 4 11] } 

e quindi ho potuto semplicemente fare qualcosa come (ancora una volta, che costituiscono una funzione chiamata freduce qui)

(freduce average (vals (map key-join list))) 

per ottenere

{"age" 5 "weight" 10 "height" 7}

Answer 1

Ecco una soluzione abbastanza prolissa. Speriamo che qualcuno può venire con qualcosa di meglio:

(let [maps [{"age" 2 "height" 1 "weight" 10}, 
      {"age" 4 "height" 4 "weight" 20}, 
      {"age" 7 "height" 11 "weight" 40}] 
     ks (keys (first maps)) 
     series-size (count maps) 
     avgs (for [k ks] 
      (/ (reduce + 
         (for [m maps] 
          (get m k))) 
       series-size))] 
    (zipmap ks avgs)) 

Answer 2

Date un'occhiata a merge-with

Ecco il mio andare a un po 'di codice vero e proprio:

(let [maps [{"age" 2 "height" 1 "weight" 10}, 
      {"age" 4 "height" 4 "weight" 20}, 
      {"age" 7 "height" 11 "weight" 40}]] 
    (->> (apply merge-with #(conj %1 %2) 
      (zipmap (apply clojure.set/union (map keys maps)) 
        (repeat [])) ; set the accumulator 
      maps) 
     (map (fn [[k v]] [k (/ (reduce + v) (count v))])) 
     (into {}))) 

Answer 3

creare la mappa dei vettori:

 
(reduce (fn [m [k v]] 
      (assoc m k (conj (get m k []) v))) 
     {} 
     (apply concat list-of-maps)) 

creare la mappa delle medie:

 
(reduce (fn [m [k v]] 
      (assoc m k (/ (reduce + v) (count v)))) 
     {} 
     map-of-vectors) 

Answer 4

Ecco un'altra versione che utilizza fusione-con senza zipmap.

(let [data [{:a 1 :b 2} {:a 2 :b 4} {:a 4 :b 8}] 
      num-vals (count data)] 
    (->> data (apply merge-with +) 
      (reduce (fn [m [k v]] (assoc m k (/ v num-vals))) {}))) 

Answer 5

(defn key-join [map-list] 
    (let [keys (keys (first map-list))] 
     (into {} (for [k keys] [k (map #(% k) map-list)])))) 
(defn mapf [f map] 
    (into {} (for [[k v] map ] [k (f v)]))) 
(defn average [col] 
    (let [n (count col) 
     sum (apply + col)] 
     (/ sum n))) 

DEMO

user=> (def data-list [{"age" 2 "height" 1 "weight" 10}, 
{"age" 4 "height" 4 "weight" 20}, 
{"age" 7 "height" 11 "weight" 40}]) 
#'user/data-list 
user=> (key-join data-list) 
{"age" (2 4 7), "height" (1 4 11), "weight" (10 20 40)} 
user=> (mapf average (key-join data-list)) 
{"age" 13/3, "height" 16/3, "weight" 70/3} 

Answer 6

Ecco la mia soluzione one-liner:

(def d [{"age" 2 "height" 1 "weight" 10}, 
    {"age" 4 "height" 4 "weight" 20}, 
    {"age" 7 "height" 11 "weight" 40}]) 

(into {} (map (fn [[k v] [k (/ v (count d))]]) (apply merge-with + d))) 

=> {"height" 16/3, "weight" 70/3, "age" 13/3} 

Logiche come segue:

• Usa fusione-con + sulle mappe per calcolare una somma per ogni valore di chiave
• dividere tutti i valori risultanti per il numero totale di mappe per ottenere una media
• inserire i risultati di nuovo in un HashMap con (in {} ...)