Могу ли я "транспонировать" список карт в карту списков в Clojure?

Question

Привет, ребята: я хочу отобразить «среднее» для всех значений на карте.скажем, у меня есть список карт:

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

И мой желаемый результат -

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

/// Ниже приведены движения моего мозга, то есть способ, которым я мог бы представить, как это работаетв Clojure ... не следует воспринимать слишком серьезно

транспонировать список:

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

и тогда я мог бы просто сделать что-то вроде (опять же, создав здесь функцию с именем freduce)

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

чтобы получить

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

Answer 1

Создание карты векторов:

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

Создание карты средних:

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

Answer 2

Вот довольно подробное решение. Надеюсь, кто-нибудь может придумать что-нибудь получше:

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

Взгляните на , объединить с

Вот мой примерный код:

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

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

ДЕМО

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 5

Вот мое однострочное решение:

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

Логика выглядит следующим образом:

• Используйте merge-with + на картах, чтобы вычислить сумму для каждого ключевого значения
• Разделите все полученные значения на общее количество карт, чтобы получить среднее значение
• Поместить результаты обратно в хеш-карту с (в {} ...)

Answer 6

Вот еще одна версия, которая использует объединение без 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))) {})))