如何有效地处理clojure中的排序数据？

我有一系列已排序的数据，希望设置邻居标志。e、 g对于以下数据，对于任何元素，如果任何邻居的标志为1，则设置

---

为该元素标记为1的任何邻居。我们可以将邻居定义为seq的diff是否基本思想是映射3个序列-原始序列，左移1，右移1：

(defn set-flags [coll]
  (map
    (fn [curr {nf :flag} {pf :flag}]
      (-> curr
          (dissoc :flag)
          (assoc :any-neighbor-flagged (if (or (= pf 1) (= nf 1)) 1 0))))
    coll
    (concat [{}] (drop-last coll))
    (concat (rest coll) [{}])))

(set-flags a) ; => ({:any-neighbor-flagged 0, :seq 1} {:any-neighbor-flagged 1, :seq 2} {:any-neighbor-flagged 0, :seq 5} {:any-neighbor-flagged 1, :seq 8} {:any-neighbor-flagged 1, :seq 10} {:any-neighbor-flagged 1, :seq 12})

图（为简单起见，仅显示

：flag

的值）：

---

现在在

map

函数中，对于每个输入元素（可能是空映射），我们也有左邻居和右邻居。基于此，很容易为

设置正确的值：任何标记为
的邻居基本思想是映射3个序列-原始序列，左移1，右移1：

(defn set-flags [coll]
  (map
    (fn [curr {nf :flag} {pf :flag}]
      (-> curr
          (dissoc :flag)
          (assoc :any-neighbor-flagged (if (or (= pf 1) (= nf 1)) 1 0))))
    coll
    (concat [{}] (drop-last coll))
    (concat (rest coll) [{}])))

(set-flags a) ; => ({:any-neighbor-flagged 0, :seq 1} {:any-neighbor-flagged 1, :seq 2} {:any-neighbor-flagged 0, :seq 5} {:any-neighbor-flagged 1, :seq 8} {:any-neighbor-flagged 1, :seq 10} {:any-neighbor-flagged 1, :seq 12})

图（为简单起见，仅显示
：flag
的值）：

现在在
map
函数中，对于每个输入元素（可能是空映射），我们也有左邻居和右邻居。基于此，很容易为
设置正确的值：任何标记为
的邻居基本思想是映射3个序列-原始序列，左移1，右移1：

(defn set-flags [coll]
  (map
    (fn [curr {nf :flag} {pf :flag}]
      (-> curr
          (dissoc :flag)
          (assoc :any-neighbor-flagged (if (or (= pf 1) (= nf 1)) 1 0))))
    coll
    (concat [{}] (drop-last coll))
    (concat (rest coll) [{}])))

(set-flags a) ; => ({:any-neighbor-flagged 0, :seq 1} {:any-neighbor-flagged 1, :seq 2} {:any-neighbor-flagged 0, :seq 5} {:any-neighbor-flagged 1, :seq 8} {:any-neighbor-flagged 1, :seq 10} {:any-neighbor-flagged 1, :seq 12})

图（为简单起见，仅显示
：flag
的值）：

现在在
map
函数中，对于每个输入元素（可能是空映射），我们也有左邻居和右邻居。基于此，很容易为
设置正确的值：任何标记为
的邻居基本思想是映射3个序列-原始序列，左移1，右移1：

(defn set-flags [coll]
  (map
    (fn [curr {nf :flag} {pf :flag}]
      (-> curr
          (dissoc :flag)
          (assoc :any-neighbor-flagged (if (or (= pf 1) (= nf 1)) 1 0))))
    coll
    (concat [{}] (drop-last coll))
    (concat (rest coll) [{}])))

(set-flags a) ; => ({:any-neighbor-flagged 0, :seq 1} {:any-neighbor-flagged 1, :seq 2} {:any-neighbor-flagged 0, :seq 5} {:any-neighbor-flagged 1, :seq 8} {:any-neighbor-flagged 1, :seq 10} {:any-neighbor-flagged 1, :seq 12})

图（为简单起见，仅显示
：flag
的值）：

现在在
map
函数中，对于每个输入元素（可能是空映射），我们也有左邻居和右邻居。基于此，很容易为
设置正确的值：使用
分区
标记的任何邻居，我们可以查看具有相邻上下文的集合

user=> (partition 3 1 (range 10))
((0 1 2) (1 2 3) (2 3 4) (3 4 5) (4 5 6) (5 6 7) (6 7 8) (7 8 9))

给定该形式的输入，我们可以使用
reduce
根据邻居比较来累积结果

user=> (pprint/pprint (reduce (fn [acc [i j k]]
                                  (conj acc
                                        (assoc j :any-neighbor-flagged
                                               (if (or (= (:flag i) 1)
                                                       (= (:flag k) 1))
                                                   1 0))))
                              []
                              (partition 3 1 (concat [nil] a [nil]))))
[{:any-neighbor-flagged 0, :seq 1, :flag 1}
 {:any-neighbor-flagged 1, :seq 2, :flag 0}
 {:any-neighbor-flagged 0, :seq 5, :flag 0}
 {:any-neighbor-flagged 1, :seq 8, :flag 0}
 {:any-neighbor-flagged 1, :seq 10, :flag 1}
 {:any-neighbor-flagged 1, :seq 12, :flag 1}]

使用
分区
，我们可以查看具有相邻上下文的集合

user=> (partition 3 1 (range 10))
((0 1 2) (1 2 3) (2 3 4) (3 4 5) (4 5 6) (5 6 7) (6 7 8) (7 8 9))

给定该形式的输入，我们可以使用
reduce
根据邻居比较来累积结果

user=> (pprint/pprint (reduce (fn [acc [i j k]]
                                  (conj acc
                                        (assoc j :any-neighbor-flagged
                                               (if (or (= (:flag i) 1)
                                                       (= (:flag k) 1))
                                                   1 0))))
                              []
                              (partition 3 1 (concat [nil] a [nil]))))
[{:any-neighbor-flagged 0, :seq 1, :flag 1}
 {:any-neighbor-flagged 1, :seq 2, :flag 0}
 {:any-neighbor-flagged 0, :seq 5, :flag 0}
 {:any-neighbor-flagged 1, :seq 8, :flag 0}
 {:any-neighbor-flagged 1, :seq 10, :flag 1}
 {:any-neighbor-flagged 1, :seq 12, :flag 1}]

使用
分区
，我们可以查看具有相邻上下文的集合

user=> (partition 3 1 (range 10))
((0 1 2) (1 2 3) (2 3 4) (3 4 5) (4 5 6) (5 6 7) (6 7 8) (7 8 9))

给定该形式的输入，我们可以使用
reduce
根据邻居比较来累积结果

user=> (pprint/pprint (reduce (fn [acc [i j k]]
                                  (conj acc
                                        (assoc j :any-neighbor-flagged
                                               (if (or (= (:flag i) 1)
                                                       (= (:flag k) 1))
                                                   1 0))))
                              []
                              (partition 3 1 (concat [nil] a [nil]))))
[{:any-neighbor-flagged 0, :seq 1, :flag 1}
 {:any-neighbor-flagged 1, :seq 2, :flag 0}
 {:any-neighbor-flagged 0, :seq 5, :flag 0}
 {:any-neighbor-flagged 1, :seq 8, :flag 0}
 {:any-neighbor-flagged 1, :seq 10, :flag 1}
 {:any-neighbor-flagged 1, :seq 12, :flag 1}]

使用
分区
，我们可以查看具有相邻上下文的集合

user=> (partition 3 1 (range 10))
((0 1 2) (1 2 3) (2 3 4) (3 4 5) (4 5 6) (5 6 7) (6 7 8) (7 8 9))

给定该形式的输入，我们可以使用
reduce
根据邻居比较来累积结果

user=> (pprint/pprint (reduce (fn [acc [i j k]]
                                  (conj acc
                                        (assoc j :any-neighbor-flagged
                                               (if (or (= (:flag i) 1)
                                                       (= (:flag k) 1))
                                                   1 0))))
                              []
                              (partition 3 1 (concat [nil] a [nil]))))
[{:any-neighbor-flagged 0, :seq 1, :flag 1}
 {:any-neighbor-flagged 1, :seq 2, :flag 0}
 {:any-neighbor-flagged 0, :seq 5, :flag 0}
 {:any-neighbor-flagged 1, :seq 8, :flag 0}
 {:any-neighbor-flagged 1, :seq 10, :flag 1}
 {:any-neighbor-flagged 1, :seq 12, :flag 1}]

@noisesmith输出不是假的，它是从REPL粘贴的。但事实上，这是一个错误。我已经解决了。@noisesmith您还错误地理解了
或
宏：
（或0）=>0，（或10）=>1，（或11）=>1
。唯一的问题是
（或0 1）=>0
而不是1。我现在明白了，是的，为指控道歉。@noisesmith输出不是假的，它是从REPL粘贴的。但事实上，这是一个错误。我已经解决了。@noisesmith您还错误地理解了
或
宏：
（或0）=>0，（或10）=>1，（或11）=>1
。唯一的问题是
（或0 1）=>0
而不是1。我现在明白了，是的，为指控道歉。@noisesmith输出不是假的，它是从REPL粘贴的。但事实上，这是一个错误。我已经解决了。@noisesmith您还错误地理解了
或
宏：
（或0）=>0，（或10）=>1，（或11）=>1
。唯一的问题是
（或0 1）=>0
而不是1。我现在明白了，是的，为指控道歉。@noisesmith输出不是假的，它是从REPL粘贴的。但事实上，这是一个错误。我已经解决了。@noisesmith您还错误地理解了
或
宏：
（或0）=>0，（或10）=>1，（或11）=>1
。唯一的问题是
（或0 1）=>0
而不是1。我现在明白了，是的，为这一指控道歉。与其使用
reduce
和
conj
，不如使用
map
——代码会更短、更干净（而且更懒）。对于需要矢量输出的情况-存在
mapv
。不使用
reduce
和
conj
可能最好使用
map
-代码将更短、更干净（并且更懒）。对于需要矢量输出的情况-存在
mapv
。不使用
reduce
和
conj
可能最好使用
map
-代码将更短、更干净（并且更懒）。对于需要矢量输出的情况-存在
mapv
。不使用
reduce
和
conj
可能最好使用
map
-代码将更短、更干净（并且更懒）。对于需要矢量输出的情况-存在
mapv
。