在Clojure中分区分区？

Question

以下是一些值。每个都是一系列的升序（或其他分组）值。

(def input-vals [[[1 :a] [1 :b] [2 :c] [3 :d] [3 :e]] 
      [[1 :f] [2 :g] [2 :h] [2 :i] [3 :j] [3 :k]] 
      [[1 :l] [3 :m]]]) 

我可以按价值分割它们。

=> (map (partial partition-by first) input-vals) 
    ((([1 :a] [1 :b]) ([2 :c]) ([3 :d] [3 :e])) (([1 :f]) ([2 :g] [2 :h] [2 :i]) ([3 :j] [3 :k])) (([1 :l]) ([3 :m]))) 

但是，我得到了3个分区序列。我想要一个单独的分区组序列。

我想要做的是返回单个惰性序列（可能）是连接的各个分区的惰性序列。例如我想产生这样：

((([1 :a] [1 :b] [1 :f] [1 :l]) ([2 :c] [2 :g] [2 :h] [2 :i]) ([3 :d] [3 :e] [3 :j] [3 :k] [3 :m]))) 

请注意，并非所有的值出现在所有序列（有第三矢量没有2）。

这当然是我的问题的简化。真实的数据是来自非常大的文件的一组惰性流，所以什么都不能实现。但我认为上述问题的解决方案是解决我的问题。

随意编辑标题，我不太确定如何表达它。

Answer 1

试试这个恐怖：

(defn partition-many-by [f comp-f s] 
    (let [sorted-s (sort-by first comp-f s) 
     first-list (first (drop-while (complement seq) sorted-s)) 
     match-val (f (first first-list)) 
     remains (filter #(not (empty? %)) 
         (map #(drop-while (fn [ss] (= match-val (f ss))) %) 
          sorted-s))] 
    (when match-val 
     (cons 
     (apply concat 
      (map #(take-while (fn [ss] (= match-val (f ss))) %) 
       sorted-s)) 
     (lazy-seq (partition-many-by f comp-f remains)))))) 

它也可能会被提高，以除去双重值检查（take-while和drop-while）。

用法示例：

(partition-many-by identity [[1 1 1 1 2 2 3 3 3 3] [1 1 2 2 2 2 3] [3]]) 

=> ((1 1 1 1 1 1) (2 2 2 2 2 2) (3 3 3 3 3 3)) 

Answer 2

我不知道我是否以下，但你可以faltten结果顺序是这样的：

(flatten (partition-by identity (first input-vals))) 

clojure.core /扁平
（[X]）
接受任何顺序事物（列表，向量，
等）的嵌套组合，并将其内容作为单个平坦序列返回。
（flatten nil）返回一个空序列。

你可以使用实现吗？函数来测试一个序列是否懒惰。

Answer 3

user> (def desired-result '((([1 :a] [1 :b] [1 :f] [1 :l]) 
          ([2 :c] [2 :g] [2 :h] [2 :i]) 
          ([3 :d] [3 :e] [3 :j] [3 :k] [3 :m])))) 
#'user/desired-result 

user> (def input-vals [[[1 :a] [1 :b] [2 :c] [3 :d] [3 :e]] 
         [[1 :f] [2 :g] [2 :h] [2 :i] [3 :j] [3 :k]] 
         [[1 :l] [3 :m]]]) 
#'user/input-vals 

user> (= desired-result (vector (vals (group-by first (apply concat input-vals))))) 
true 

我改变了输入丘壑稍微纠正什么，我认为是一个拼写错误，如果它是不是一个错误，我可以更新我的代码，以适应结构比较松散。

使用->>（线程最后）宏，我们可以有相当的代码更可读的形式：

user> (= desired-result 
     (->> input-vals 
      (apply concat) 
      (group-by first) 
      vals 
      vector)) 
true 

Answer 4

让我们把这个有趣和使用无限长度的序列为我们输入

(def twos (iterate #(+ 2 %) 0)) 
(def threes (iterate #(+ 3 %) 0)) 
(def fives (iterate #(+ 5 %) 0)) 

我们需要懒洋洋地合并。我们要求一个比较器，以便我们也可以应用于其他数据类型。

(defn lazy-merge-by 
([compfn xs ys] 
    (lazy-seq 
    (cond 
     (empty? xs) ys 
     (empty? ys) xs 
     :else (if (compfn (first xs) (first ys)) 
       (cons (first xs) (lazy-merge-by compfn (rest xs) ys)) 
       (cons (first ys) (lazy-merge-by compfn xs (rest ys))))))) 
    ([compfn xs ys & more] 
    (apply lazy-merge-by compfn (lazy-merge-by compfn xs ys) more))) 

测试

(take 15 (lazy-merge-by < twos threes fives)) 
;=> (0 0 0 2 3 4 5 6 6 8 9 10 10 12 12) 

我们可以（懒惰）由值分区如果需要

(take 10 (partition-by identity (lazy-merge-by < twos threes fives))) 
;=> ((0 0 0) (2) (3) (4) (5) (6 6) (8) (9) (10 10) (12 12)) 

现在，回到样品输入

(partition-by first (apply lazy-merge-by #(<= (first %) (first %2)) input-vals)) 
;=> (([1 :a] [1 :b] [1 :f] [1 :l]) ([2 :c] [2 :g] [2 :h] [2 :i]) ([3 :d] [3 :e] [3 :j] [3 :k] [3 :m])) 

根据需要少一个多余的一组外部括号。

Answer 5

(partition-by first (sort-by first (mapcat identity input-vals)))