在 clojure 中有效地映射向量的一部分

Question

我想知道如何在 Clojure 中以惯用且有效的方式做到这一点：

1) 给定一个包含 n 个整数的向量： [A₀ A₁ A₂ A₃ ... A_n]

2) 将最后的 x 项加 1（假设 x 为 100），因此向量将变为： [A₀ A₁ A_{2 A3 ... (An-99 + 1) (An-98 + 1)... (A n-1 + 1) (An + 1)]}

一个简单的实现如下所示：

(defn inc-last [x nums]
  (let [n (count nums)]
      (map #(if (>= % (- n x)) (inc %2) %2)
           (range n) 
           nums)))

(inc-last 2 [1 2 3 4]) 
;=> [1 2 4 5]

在这个实现中，基本上你只是通过检查每个项目来将整个向量映射到另一个向量，看看它是否需要增加。

但是，这是一个 O(n) 操作，而我只想更改向量中的最后 x 个项目。理想情况下，这应该在 O(x) 而不是 O(n) 中完成。

我正在考虑使用诸如 split-at/concat 之类的函数来实现它，如下所示：

(defn inc-last [x nums]
  (let [[nums1 nums2] (split-at x nums)]
    (concat nums1 (map inc nums2))))

但是，我不确定这个实现是 O(n) 还是 O(x)。我是 Clojure 的新手，不太确定在 Clojure 中对持久数据结构进行 concat/split-at 等操作的时间复杂度是多少。

所以我的问题是：

1) 第二个实现的时间复杂度是多少？

2）如果还是O(n)，有没有Clojure中只需要O(x)的惯用高效的实现来解决这个问题？

感谢任何评论。谢谢。

更新：

noisesmith 的回答告诉我 split-at 会将向量转换为列表，这是我之前没有意识到的事实。由于我将对结果进行随机访问（在处理向量后调用nth），我希望有一个有效的解决方案（O(x) 时间）同时保留向量而不是列表，否则nth 会减慢我的速度程序也是如此。

Answer 1

Concat 和 split-at 都将输入转换为 seq，实际上是链表表示，时间为 O(x)。以下是如何使用向量来实现 O(n) 性能。

user> (defn inc-last-n
        [n x]
        (let [count (count x)
              update (fn [x i] (update-in x [i] inc))]
          (reduce update x (range (- count n) count))))
#'user/inc-last-n
user> (inc-last-n 3 [0 1 2 3 4 5 6])
[0 1 2 3 5 6 7]

这将在非关联输入（如 seq/lazy-seq）上失败，因为在非关联类型中没有 O(1) 访问时间。

Answer 2

inc-last 是一个使用transient 的实现，它允许在恒定时间内获得一个可修改的“就地”向量并在恒定时间内返回一个persistent! 向量，它允许在 O( X）。 最初的实现使用命令式doseq 循环，但正如 cmets 中所提到的，瞬态操作可以返回一个新对象，因此最好继续以函数式方式进行操作。

我在对inc-last-2 的调用中添加了doall，因为它返回一个惰性序列，但inc-last 和inc-last-3 返回一个向量，因此需要doall 才能比较它们。

根据我进行的一些快速测试，inc-last 和 inc-last-3 实际上在性能上并没有太大差异，即使对于巨大的向量（10000000 个元素）也是如此。不过，对于inc-last-2 实现，即使对于 1000 个元素的向量，也存在很大差异，仅修改最后 10 个元素，它的速度要慢约 100 倍。对于较小的向量或当n 接近(count nums) 时，差异并没有那么大。

（感谢 Michał Marczyk 提供有用的 cmets）

(def x (vec (range 1000)))

(defn inc-last [n x]
  (let [x (transient x)
        l (count x)]
    (->>
      (range (- l n) l)
      (reduce #(assoc! %1 %2 (inc (%1 %2))) x)
      persistent!)))

(defn inc-last-2 [x nums]
  (let [n (count nums)]
    (map #(if (>= % (- n x)) (inc %2) %2)
         (range n) 
         nums)))

(defn inc-last-3 [n x]
  (let [l (count x)]
    (reduce #(assoc %1 %2 (inc (%1 %2))) x (range (- l n) l))))

(time
  (dotimes [i 100]
    (inc-last 50 x)))

(time
  (dotimes [i 100]
    (doall (inc-last-2 10 x))))

(time
  (dotimes [i 100]
    (inc-last-3 50 x)))

;=> "Elapsed time: 49.7965 msecs"
;=> "Elapsed time: 1751.964501 msecs"
;=> "Elapsed time: 67.651 msecs"