通过“窗口化”分区在Clojure中的谓词 [英] Partition a seq by a "windowing" predicate in Clojure

问题描述

我想将seq分块到subseqs与partition-by相同，除了该函数不应用于每个单个元素，而是应用于一系列元素。

I would like to "chunk" a seq into subseqs the same as partition-by, except that the function is not applied to each individual element, but to a range of elements.

因此，例如：

(gather (fn [a b] (> (- b a) 2)) 
        [1 4 5 8 9 10 15 20 21])

[[1] [4 5] [8 9 10] [15] [20 21]]

同样：

(defn f [a b] (> (- b a) 2))
(gather f [1 2 3 4]) ;; => [[1 2 3] [4]]
(gather f [1 2 3 4 5 6 7 8 9]) ;; => [[1 2 3] [4 5 6] [7 8 9]]

我应用列表的开始和函数的下一个元素，如果函数返回true，我们将列表的当前头部分成一个新的分区。

The idea is that I apply the start of the list and the next element to the function, and if the function returns true we partition the current head of the list up to that point into a new partition.

我写了：

(defn gather
  [pred? lst]
  (loop [acc [] cur [] l lst]
    (let [a (first cur)
          b (first l)
          nxt (conj cur b)
          rst (rest l)]
      (cond
       (empty? l) (conj acc cur)
       (empty? cur) (recur acc nxt rst)
       ((complement pred?) a b) (recur acc nxt rst)
       :else (recur (conj acc cur) [b] rst)))))

它的工作原理，但我知道有一个更简单的方法。我的问题是：

and it works, but I know there's a simpler way. My question is:

有没有内置函数来做这个功能，这个函数是不必要的？如果没有，是否有一个更为惯用（或更简单）的解决方案，我忽略了？

Is there a built in function to do this where this function would be unnecessary? If not, is there a more idiomatic (or simpler) solution that I have overlooked? Something combining reduce and take-while?

推荐答案

我们（所有）似乎误解了你的问题，因为想要在连续元素的谓词持有时启动一个新的分区。

Original interpretation of question

We (all) seemed to have misinterpreted your question as wanting to start a new partition whenever the predicate held for consecutive elements.

另一个，懒惰，建立在分区

Yet another, lazy, built on partition-by

(defn partition-between [pred? coll] 
  (let [switch (reductions not= true (map pred? coll (rest coll)))] 
    (map (partial map first) (partition-by second (map list coll switch)))))

---

---

(partition-between (fn [a b] (> (- b a) 2)) [1 4 5 8 9 10 15 20 21])
;=> ((1) (4 5) (8 9 10) (15) (20 21))

（（5 5）（8 9 10）实际问题

实际问题要求我们在开始时 pred 的当前分区和当前元素。对于这个，我们可以通过对它的源进行一些调整来破坏 partition-by 。

(defn gather [pred? coll]
  (lazy-seq
   (when-let [s (seq coll)]
     (let [fst (first s)
           run (cons fst (take-while #((complement pred?) fst %) (next s)))]
       (cons run (gather pred? (seq (drop (count run) s))))))))

---

---

(gather (fn [a b] (> (- b a) 2)) [1 4 5 8 9 10 15 20 21])
;=> ((1) (4 5) (8 9 10) (15) (20 21))

(gather (fn [a b] (> (- b a) 2)) [1 2 3 4])
;=> ((1 2 3) (4))

(gather (fn [a b] (> (- b a) 2)) [1 2 3 4 5 6 7 8 9])
;=> ((1 2 3) (4 5 6) (7 8 9))

这篇关于通过“窗口化”分区在Clojure中的谓词的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！