3

我想编写一个函数来交错两个给定的序列。该功能应该像这样工作：

user=> (ext-interl '(1 2 3 4 5 6 7 8) '(a b c))
(1 a 2 b 3 c 4 a 5 b 6 c 7 a 8 b)

该过程将在达到更长的序列时结束。

我的代码是：

(defn ext-interl [l1 l2]
 (lazy-seq
  (let [ls1 (seq l1) ls2 (seq l2)]
    (cond (and ls1 ls2)
     (cons (first ls1) (cons (first ls2) (ext-interl (rest ls1) (rest ls2))))
     ls1 ls1
     ls2 ls2))))

但是这段代码运行如下：

 user=> (ext-interl '(1 2 3 4 5 6 7 8) '(a b c))
(1 a 2 b 3 c 4 5 6 7 8)

如何修复此代码？谢谢！

4

2 回答 2

4

这里有三个版本：一个简单的、严格的；一个基于clojure.core组合器的懒惰的；和一个基于相同组合器的惰性组合器，它接受任意数量的输入。

一个简单的严格方法

对惰性方法的健全性检查。

(defn interleave-longer-strict [xs ys]
  (take (* 2 (max (count xs) (count ys)))
    (interleave (cycle xs) (cycle ys))))

基于组合器的惰性方法

这是一个基于map, mapcat, take-while, iterate,interleave和的懒惰版本cycle：

(defn interleave-longer
  "Lazy version of

    (take (* 2 (max (count xs) (count ys)))
      (interleave (cycle xs) (cycle ys)))"
  [xs ys]
  (map (fn [_ e] e)
    (mapcat (fn [[xs ys]] [[xs ys] [xs ys]])
      (take-while (fn [[xs ys]] (or xs ys))
        (iterate (fn [[xs ys]] [(next xs) (next ys)])
          [xs ys])))
    (interleave (cycle xs) (cycle ys))))

为了证明它确实是惰性的（注意，(range)永远不会返回——如果你真的通过 消耗它Long/MAX_VALUE，它只会开始返回clojure.lang.BigInts）：

(take 30 (interleave-longer (range) (range 11)))
;= (0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 11 0 12 1 13 2 14 3)

(take 30 (interleave-longer (range 11) (range)))
;= (0 0 1 1 2 2 3 3 4 4 5 5 6 6 7 7 8 8 9 9 10 10 0 11 1 12 2 13 3 14)

使用可变参数的基于组合器的惰性方法

最后，一个基于相同原语的惰性版本 plus apply, repeatand count（应用于 varargs seq 以确定有多少输入）接受任意数量的输入：

(defn interleave-longest [& xss]
  (map (fn [e & _] e)
    (apply interleave (map cycle xss))
    (mapcat (fn [xss] (repeat (count xss) xss))
      (take-while (fn [xss] (some some? xss))
        (iterate (fn [xss] (mapv next xss))
          xss)))))

在 REPL：

(interleave-longest [:a :b :c :d] (range 11) '[x y z])
;= (:a 0 x :b 1 y :c 2 z :d 3 x :a 4 y :b 5 z :c 6 x :d 7 y :a 8 z :b 9 x :c 10 y)

(take 30 (interleave-longest [:a :b :c :d] (range) '[x y z]))
;= (:a 0 x :b 1 y :c 2 z :d 3 x :a 4 y :b 5 z :c 6 x :d 7 y :a 8 z :b 9 x)
于 2016-05-02T23:54:43.510 回答
3

您的解决方案在您的第二个和第三cond个子句中失败：当其中一个序列完全使用时，您只需将剩余的一个附加到末尾。您可能需要调用另一个函数，从一开始就将剩余的集合与另一个循环合并。例如：

(defn- ext-interleave' [orig-xs xs orig-ys ys]
  (let [xs (seq xs)
        ys (seq ys)]
    (cond
      (and xs ys)
      (concat
        [(first xs) (first ys)]
        (ext-interleave' orig-xs (rest xs) orig-ys (rest ys)))

      xs
      (interleave xs (cycle orig-ys))

      ys
      (interleave (cycle orig-xs) ys))))

(defn ext-interleave [xs ys]
  (ext-interleave' xs xs ys ys))

(ext-interleave [1 2 3 4 5 6 7 8] '[a b c])

cond这个解决方案在第一个分支中主要是惰性的（它急切地消耗两个序列中的两个第一个项目） 。

如果您不需要惰性解决方案，我会使用现有功能来完成这项工作：

  • cycle+take根据需要制作您的序列
  • 核心interleave将它们结合起来

解决方案：

(defn ext-interleave [xs ys]
  (let [l (max (count xs) (count ys))
        xs (take l (cycle xs))
        ys (take l (cycle ys))]
    (interleave xs ys)))
(ext-interleave [1 2 3 4 5 6 7 8] '[a b c])
;; => (1 a 2 b 3 c 4 a 5 b 6 c 7 a 8 b)

您甚至可以使其适用于任意数量的输入序列：

(defn ext-interleave' [& cols]
  (let [l (apply max (map count cols))
        cols (map #(take l (cycle %)) cols)]
    (apply interleave cols)))

(ext-interleave' [1 2 3 4 5 6 7 8] '[a b c] [:y :z])
;; => (1 a :y 2 b :z 3 c :y 4 a :z 5 b :y 6 c :z 7 a :y 8 b :z)

提供的解决方案不会是懒惰的，因为count它将强制实现您的输入序列以计算它们的元素。

于 2016-05-02T20:03:36.020 回答