Question

我需要修改地图功能行为以提供不是最小集合大小的映射，但是最大值并且对于缺少的元素使用零。

标准行为：

(map + [1 2 3] [4 5 6 7 8]) => [5 7 9]

需要的行为：

(map + [1 2 3] [4 5 6 7 8]) => [5 7 9 7 8]

我编写了函数来执行此操作，但它似乎无法用varargs进行扩展。

(defn map-ext [f coll1 coll2]
  (let [mx (max (count coll1) (count coll2))]
    (map f
     (concat coll1 (repeat (- mx (count coll1)) 0))
     (concat coll2 (repeat (- mx (count coll2)) 0)))))

有更好的方法吗？

Answer 1

您的方法简洁，但效率低下（它调用count）。一个更有效的解决方案，它不需要将整个输入序列存储在内存中：

(defn map-pad [f pad & colls]
  (lazy-seq
   (let [seqs (map seq colls)]
     (when (some identity seqs)
       (cons (apply f (map #(or (first %) pad) seqs))
             (apply map-pad f pad (map rest seqs)))))))

像这样使用：

user=> (map-pad + 0 [] [1] [1 1] (range 1 10))
(3 3 3 4 5 6 7 8 9)

修改：将map-pad广义化为任意区域。

Answer 2

另一种惰性变体，可与任意数量的输入序列一起使用：

(defn map-ext [f ext & seqs]
  (lazy-seq
   (if (some seq seqs)
     (cons (apply f (map #(if (seq %) (first %) ext) seqs))
           (apply map-ext f ext (map rest seqs)))
     ())))

用法：

user> (map-ext + 0 [1 2 3] [4 5 6 7 8])
(5 7 9 7 8)

user> (map-ext + 0 [1 2 3] [4 5 6 7 8] [3 4])
(8 11 9 7 8)

Answer 3

如果您只想让它适用于任意数量的集合，请尝试：

(defn map-ext [f & colls] 
  (let [mx (apply max (map count colls))]
      (apply map f (map #(concat % (repeat (- mx (count %)) 0)) colls))))

Clojure> (map-ext + [1 2] [1 2 3] [1 2 3 4])
(3 6 6 4)

我怀疑可能有更好的解决方案（正如Trevor Caira所说，由于要求计数，这个解决方案并不是懒惰的。）

Answer 4

怎么样：

(defn map-ext [f x & xs]
  (let [colls (cons x xs)
        res   (apply map f colls)
        next  (filter not-empty (map #(drop (count res) %) colls))]
    (if (empty? next) res
        (lazy-seq (concat res (apply map-ext f next))))))

user> (map-ext + [1 2 3] [4] [5 6] [7 8 9 10]) 
(17 16 12 10)

Answer 5

沿着@LeNsTR's solution，但更简单，更快：

(defn map-ext [f & colls]
  (lazy-seq
   (let [colls (filter seq colls)
         firsts (map first colls)
         rests (map rest colls)]
    (when (seq colls)
      (cons (apply f firsts) (apply map-ext f rests))))))

(map-ext + [1 2 3] [4] [5 6] [7 8 9 10])
;(17 16 12 10)

我刚刚注意到MichałMarczyk所接受的解决方案，它更优越：它可以正确处理非-等非对称映射函数。

Answer 6

我们可以通过使用惯例（许多核心函数遵循）来使EndRead更整洁 - 通过调用不带参数的函数来获取默认值或标识值。例如：

(+) ;=> 0
(concat) ;=> ()

代码变为

(defn map-ext [f & seqs]
  (lazy-seq
   (when (some seq seqs)
     (cons (apply f (map #(if (seq %) (first %) (f)) seqs))
           (apply map-ext f (map rest seqs)))
     )))

(map-ext + [1 2 3] [4 5 6 7 8] [3 4])
;(8 11 9 7 8)

我做了最小的改动。它可能会加速一点。

我们可能需要一个将这种默认值注入缺少它的函数的函数：

(defn with-default [f default]
  (fn
    ([] default)
    ([& args] (apply f args))))

((with-default + 6)) ;=> 6
((with-default + 6) 7 8) ;=> 15

这可能会加速甚至变成一个宏。

在Clojure中更改地图行为

6 个答案: