如何将列表转换为子列表？

Question

((1 2 3)
(2 3 4)
(3 4 5)
(4 5 6))

来自

(1 2 3 4 5 6)

这种操作的类型是什么？

我尝试了什么：

(loop
   :with l2 = '()
   :with l1 = '(1 2 3 4 5 6)
   :for i :in l1
   :do (push (subseq l1 0 3) l2))

Answer 1

每次循环都推送同一个子列表。

您可以使用:for sublist on 循环遍历列表的连续尾部。

并使用:collect 列出所有结果，而不是推送到您自己的列表中

(loop
   :for l1 on '(1 2 3 4 5 6)
   :if (>= (length l1) 3)
      :collect (subseq l1 0 3)
   :else 
      :do (loop-finish))

Answer 2

或者使用map:

(let ((l '(1 2 3 4 5 6)))
  (map 'list #'list l (cdr l) (cddr l)))

;; ((1 2 3) (2 3 4) (3 4 5) (4 5 6))

你可以这样理解：

• 用于列表 l 与值 (1 2 3 4 5 6)
• map 超过列表及其两个连续的cdrs
• 通过在列表的元素上应用#'list map 是并行循环的
• （当最短列表用完时停止）
• 并将结果收集为'list

@WillNess 建议更简单：

(let ((l '(1 2 3 4 5 6)))
  (mapcar #'list l (cdr l) (cddr l)))

谢谢！那么我们可以只使用map 变体进行泛化：

(defun subseqs-of-n (l n)
  (apply #'mapcar #'list (subseq (maplist #'identity l) 0 n)))

(maplist #'identity l) 等价于(loop for sl on l collect sl)。 不过，

(loop for sl on l
      for i from 0 to n
      collect sl)

更好，因为它在第 n 轮循环处停止...

Answer 3

首先让我们定义一个函数take-n，如果没有足够的项目，它要么返回n 个项目，要么返回一个空列表。它不会扫描整个列表。

(defun take-n (n list)
  (loop repeat n
        when (null list) return (values nil nil)
        collect (pop list)))

然后我们将这个函数take-n移到列表上，直到它返回NIL。

(defun moving-slice (n list)
  (loop for l on list
        for p = (take-n n l)
        while p
        collect p))

例子：

CL-USER 207 > (moving-slice 3 '(1 2))
NIL

CL-USER 208 > (moving-slice 3 '(1 2 3))
((1 2 3))

CL-USER 209 > (moving-slice 3 '(1 2 3 4 5 6 7))
((1 2 3) (2 3 4) (3 4 5) (4 5 6) (5 6 7))

Answer 4

这是 Barmar 的答案的一个版本（应该是公认的），它更笼统，只调用一次 length。

(defun successive-leading-parts (l n)
  (loop repeat (1+ (- (length l) n))
        for lt on l
        collect (subseq lt 0 n)))

> (successive-leading-parts '(1 2 3 4) 3)
((1 2 3) (2 3 4))

> (successive-leading-parts '(1 2 3 4) 2)
((1 2) (2 3) (3 4))

Answer 5

或者经典的更多C-like for-loop-ing 用索引来解决它。 但是更多地在字符串/向量上使用它，而不是在列表上使用它，因为它的性能是

• 对于二次列表
• 用于向量（字符串！）线性，因此最好与它们一起使用！

感谢@WillNess，他指出了这两个点（参见下面的 cmets）。

(defun subseqs-of-n (ls n) ;; works on strings, too!
  (loop :for i :from 0 :to (- (length ls) n)
        :collect (subseq ls i (+ i n))))

所以在向量/字符串上使用：

(subseqs-of-n "gattaca" 5)
;; ("gatta" "attac" "ttaca")