¿Puedo "transponer" una lista de mapas en un mapa de listas en Clojure?

Question

Hola, amigos: Quiero mapear un "promedio" para todos los valores en un mapa. decir que tengo una lista de mapas:

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

Y mi salida deseada es

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

/// A continuación se presentan las divagaciones de mi cerebro, es decir, la forma en que podría imaginar que este trabajo en Clojure .. .no ser tomado demasiado en serio

transponer la lista:

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

y luego yo podría simplemente hacer algo al igual que (una vez más, lo que representa una función llamada freduce aquí)

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

para obtener

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

Answer 1

Aquí hay una solución bastante detallada. Esperemos que alguien puede llegar a algo mejor:

(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

Tome un vistazo a merge-with

Aquí está mi ir en algún código real:

(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

crear el mapa de vectores:

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

crear el mapa de los promedios:

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

Answer 4

Aquí hay otra versión que utiliza fusionar-con sin 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

es mi solución de una sola línea aquí:

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

Lógicas de la siguiente manera:

• Uso fusionar-con + en los mapas para calcular una suma para cada valor de la clave
• dividir todos los valores resultantes por el número total de mapas para obtener un promedio
• puso a los resultados de vuelta en un HashMap con (en {} ...)