延续单调栈的思路，运用空间想象力，要想接住雨水，必须要找到一个「凹」形区域。如果从左向右遍历，先是遍历到一些从高到低的柱子，直到遇到一个比当前最低的柱子高的柱子，并且栈里还有柱子（要注意至少有三根柱子，数字0也看作高度0的柱子），就意味着「凹」形区域形成了。

首先用一个单调栈维护递减的柱子高度。如图所示，当找到这样一个可以接水的区域时，可以以水平切片的方式，逐步求出当前柱子到栈顶柱子间水平切片可以装的水量。

每一个水平切片都是一个矩形，面积是宽高相乘，宽度是当前柱子索引减去左侧柱子索引再加1；高度根据木桶效应，应当取当前柱子和左侧柱子高度较小的那个，同时不能忘记，要减去已经算过的上一层高度。

汇总一下信息：

1. 单调栈维护​高度递减​的柱子（为了方便计算，可以保存索引）
2. 遇到比栈顶高的柱子，出栈，根据前面提到的水平切片计算方法，更新答案
3. 直到​栈空​或​栈里只有一根柱子​或当前柱子​比栈顶矮​，继续遍历下一个柱子

代码：

(define (trap height)
  (let loop ((height height)
             (i 0)
             ;; 保存索引和高度
             (stack '())
             (ans 0))
    (if (null? height)
        ans
        (let ((h (car height)))
          (cond ((null? stack) ; 栈空，入栈
                 (loop (cdr height) (1+ i) (cons (cons i h) stack) ans))
                ((< h (cdr (car stack))) ; 更矮的柱子，入栈
                 (loop (cdr height) (1+ i) (cons (cons i h) stack) ans))
                (else
                 (let ((pre-h (cdr (car stack))) ; 上一层的高
                       (pop-stack (cdr stack))) ; 栈顶出栈后剩下的栈
                   (if (null? pop-stack)
                       ;; 柱子不够形成凹形区域，继续向后找
                       (loop (cdr height) (1+ i) (cons (cons i h) pop-stack) ans)
                       (let* ((left (car pop-stack))
                              (left-i (car left))
                              (left-h (cdr left))
                              (width (- i left-i 1))
                              (height-diff (- (min left-h h) pre-h)))
                         (loop height
                               i
                               pop-stack
                               (+ ans (* width height-diff))))))))))))

前后缀分解#

也可以竖着去切片，每次算竖着的一格可以装多少水，那么每个矩形区域的宽度就固定了，但是怎么知道高度呢？

以图中第三个矩形为例，作为一个大的可以接水的区域的一部分，这整个区域的水面高度肯定是取决于整个区域两端柱子中较矮的那个。从第3个矩形的位置向左右两边看，水面高度应该取决于向左能看到的最高柱子以向右能看到的最高柱子中较矮的那个，在这个例子中是最后一个柱子。

如果能知道每一个位置上，向左看最高的柱子以向右看最高的柱子，不就可以据此算出当前位置能接的水了吗？

写两个函数，根据输入的列表，一次性算出每个位置前向和后向的最高柱子：

(define (prefix-max lst)
  (let loop ((lst lst)
             (max-val -1)
             (result '()))
    (if (null? lst)
        (reverse result)
        (let ((new-max (max max-val (car lst))))
          (loop (cdr lst) new-max (cons new-max result))))))

(define (suffix-max lst)
  (let loop ((lst (reverse lst))
             (max-val -1)
             (result '()))
    (if (null? lst)
        result
        (let ((new-max (max max-val (car lst))))
          (loop (cdr lst) new-max (cons new-max result))))))

剩下要做的就是同时遍历三个列表，求出每个位置的水量再加总就可以了：

(define (trap height)
  (let loop ((pre-max (prefix-max height))
             (suf-max (suffix-max height))
             (height height)
             (ans 0))
    (if (null? height)
        ans
        (let ((p (car pre-max))
              (s (car suf-max))
              (h (car height)))
          (loop (cdr pre-max)
                (cdr suf-max)
                (cdr height)
                (+ ans (- (min p s) h)))))))

相向双指针#

注意到上一个方法用了两个列表存前缀最大和后缀最大，空间复杂度是​O(n)​，能否优化？

可以维护两个指针，从柱子的头尾相向遍历，总是移动较矮的那一端，移动的同时记录当前最大并更新答案。

(define (trap height)
  (let ((n (vector-length height)))
    (let loop ((left 0)
               (right (- n 1))
               (pre-max 0)
               (suf-max 0)
               (ans 0))
      (if (< left right)
          (let ((new-pre-max (max pre-max (vector-ref height left)))
                (new-suf-max (max suf-max (vector-ref height right))))
            ;; 哪边矮动哪边，动一格，算一格
            (if (< new-pre-max new-suf-max)
                (loop (+ left 1)
                      right
                      new-pre-max
                      new-suf-max
                      ;; 如果当前柱子就是最高，就是加上0，等于没有更新答案
                      ;; 否则一减就是水的高度，宽度是1，不用乘
                      (+ ans (- new-pre-max (vector-ref height left))))
                (loop left
                      (- right 1)
                      new-pre-max
                      new-suf-max
                      (+ ans (- new-suf-max (vector-ref height right))))))
          ans))))

暴力法#

使用暴力方法做这题很简单，首先拆解出一个子问题：给你一个索引i和一个数组a，找出数组中i之后第一个大于a[i]的数的索引j，没有就返回0。

(define (find-first-larger i a)
  (let loop ((j (+ i 1)))
    (cond
     ;; 到最后还没有找到，返回0
     ((= j (vector-length a)) 0)
     ;; a[j] > a[i]，返回j
     ((> (vector-ref a j) (vector-ref a i)) j)
     ;; 否则继续往后找
     (else (loop (+ j 1))))))

剩下的事情就是遍历原数组，对每一个索引i调用​find-first-larger​，组合得到新的数组就是答案了。

暴力做法的时间复杂度是​O(n^2)​，有没有方法在线性时间解决问题呢？

单调栈#

可以先尝试用动态规划的思路，假设当前在原数组任意位置，有哪些可能的状态？

1. 当前数前面的数都已经找到了答案
2. 当前数前面还有数没有找到答案

首先分析情况一，如果说刚刚遍历到当前数，还没有做任何操作，而前方没有任何未找到答案的数，那只能说明当前数是第一个数。

所以情况二才是需要重点分析的，如果前方有数没有找到答案，这些数会有什么性质？

如果在遍历过程中将没找到答案的数按顺序记录下来，这些数有可能是​[2, 4, 3]吗？​不可能​，为什么呢？因为题目指明了要找每一个数的下一个更大的数，如果2后面有4的话，2不可能被归类在没有答案的部分。也就是说如果按从左到右的顺序记录当前还没找到答案的数，这些数一定是​非递增​的。

那么如果当前数x小于等于这个记录中最右边的数y，也就意味着当前数x不可能是y的答案，更加不可能是记录中其它数的答案。至此在当前位置除了将当前数也加入未找到答案的记录中就无事可做了。

反之如果当前数x大于y，那么可以说y的答案就是当前数x，可以将y从未找到答案的记录中删去，但是还不知道当前数是否有可能仍然是剩下的记录中的数的答案，所以还要重复这个比较过程，直接剩下记录最右边也就是记录中最小的数都大于等于当前数x。

总结描述一下过程，设当前数为x，未找到答案的数的记录称为pending：

1. 若pending为空，将x存入pending，遍历下一个数
2. pending不为空，将最新存入pending的数取出，设为y，与x比较：
   • 若x > y，则，从pending中删去y，y的答案记为x，重复步骤1、2
   • 否则，将x存入pending，遍历下一个数

可见这个pending需要用一个​后入先出​的数据结构，那么最合适的就是栈了。又由于之前已经证明，pending内的元素具有单调性，所以这种结构被称为单调栈。

注意到这里有一个内层循环，但是时间复杂度并不是​O(n^2)​，即使考虑极端情况​[100, 99, 98, 97, 96]​，也顶多每个元素入栈出栈一次，最终时间复杂度还是​O(n)​的。

另外题目要求的是几天后会出现一个更高温度，pending可以用来存索引，更新答案是用当前索引减去栈顶存储的索引就可以了。

(define (daily-temperatures temperatures)
  (let* ((n (vector-length temperatures))
         (ans (make-vector n 0)))
    (let loop ((i 0)
               ;; 用链表做栈
               (pending '()))
      (if (< i n)
          (if (null? pending)
              ;; pending为空，进入下一步
              (loop (+ i 1)
                    ;; 为了更新答案方便，pending实际存的是索引
                    (cons i pending))
              (let* ((x (vector-ref temperatures i))
                     (j (car pending))
                     (y (vector-ref temperatures j)))
                (if (> x y)
                    (begin
                      (vector-set! ans j (- i j))
                      (loop i (cdr pending)))
                    (loop (+ i 1)
                          (cons i pending)))))
          ans))))

还有一种倒着遍历的思路，代码写出来似乎没有从左到右遍历易懂，但是描述却非常形象：

将题目给的数组想象成连续的山峰的高度，如​[2, 4, 5, 1, 2, 6]​，倒着遍历，将遍历过程想象成爬山，假设当前爬到高度为4的山峰，那么​[5, 1, 2, 6]​是已经爬过的，现在你人站在山上向后看，是不是只能看到高度为5和6的两座山峰呢？因为比5矮的两座被挡住了嘛。

说回题目，也就是说处在4的位置上，只有6和5才有资格继续做可能的答案。

推广一下，如果用pending记录有可能作为前面的数字的答案的数，pending一定是​非递减​的。

具体地说，倒着遍历数组，设当前数x，用pending记录可能作为前面数字答案的数：

1. pending为空，将当前数推入pending
2. pending不为空，比较x和于pending栈顶的数y
   • x大于等于y，y就不可能是前面某个数的答案，将y弹出，重复步骤1、2
   • 否则，y就是x的答案，更新答案，x还有可能是前面某个数的答案，x推入pending

(define (daily-temperatures temperatures)
  (let* ((n (vector-length temperatures))
         (ans (make-vector n 0)))
    (let loop ((i (- n 1))
               (pending '()))
      (if (> i -1)
          (if (null? pending)
              (loop (- i 1)
                    (cons i pending))
              (let* ((x (vector-ref temperatures i))
                     (j (car pending))
                     (y (vector-ref temperatures j)))
                (if (>= x y)
                    (loop i
                          (cdr pending))
                    (begin
                      (vector-set! ans i (- j i))
                      (loop (- i 1)
                            (cons i pending))))))
          ans))))

总结#

和暴力做法相比，单调栈做法是充分利用了单调性来节省多余的计算。不论单调栈pending存储的是待找到答案的部分（从左到右遍历），还是可能作为答案的部分（从右到左遍历）。用暴力法，如果给你待找到答案的部分，你可能会逐个与当前数作比较，但是只要能想到利用单调性，如未找到答案部分一定是非递增的，那么只用将栈顶元素也就是最小的元素与当前数作比较了。

因为数组是有序的，如果从数组两头向中间遍历，两端数之和大于目标，说明要找一个更小的数，需要左移右指针；如果两端数之和小于目标，说明要找一个更大的数，需要右移左指针：

(define (two-sum numbers target)
  (let loop ((left 0)
             (right (- (vector-length numbers) 1)))
    (if (< left right)
        (let ((sum (+ (vector-ref numbers left)
                      (vector-ref numbers right))))
          (cond
           ((> sum target) (loop left (- right 1)))
           ((< sum target) (loop (+ left 1) right))
           (else (list left right))))
        (list -1 -1))))

不过题目有个小陷阱，特别提到数组下标从1开始，只要最后返回的地方两个指针都加一就可以了。

633. 平方数之和#

既然是找平方的和等于c的两个数，说明要找的两个数一定比c小，准确地说是要不超过根号c（向下取整），设为k。题目说明了是整数里找，整数有无限个，虽然确定了上限k，下限怎么定呢？注意-a的平方和a的平方是相同的，所以可以把这一题转换为在元素为0到k的整数数组中，找两个数平方和等于c，只是计数时不能忽略c刚好为-a的平方加a的平方的情况，循环条件应为​left <= right​。

(define (judge-square-sum c)
  (let loop ((left 0)
             (right (inexact->exact (floor (sqrt c)))))
    (if (<= left right)
        (let ((sum (+ (* left left)
                      (* right right))))
          (cond
           ((> sum c) (loop left (- right 1)))
           ((< sum c) (loop (+ left 1) right))
           (else #t)))
        #f)))

2824. 统计和小于目标的下标对数目#

题目中的​i < j​条件容易引起误解，实际只是在说指针不能在同一个位置。可以排序再应用求两数和的方法，当左右指针下值相加小于target，说明当前左指针下数加​[left + 1, right]​指针下任一数（右指针下一定是区间内最大的），都小于target，也就是有​right - left​个下标对符合条件。

(define (count-pairs nums target)
  (let ((sorted (sort nums <)))
    (let loop ((left 0)
               (right (- (vector-length sorted) 1))
               (ans 0))
      (if (< left right)
          (let ((sum (+ (vector-ref sorted left)
                        (vector-ref sorted right))))
            (if (< sum target)
                (loop (+ left 1)
                      right
                      (+ ans (- right left)))
                (loop left
                      (- right 1)
                      ans)))
          ans))))

15. 三数之和#

需要找x,y,z和等於0，可以排序数组，遍历数组，以当前数为x，题目就变成了找y + z = -x的双指针问题了。

先試試在有序的數組中，找y和z：

(define (find-y-z nums x)
  (let loop ((left 0)
             (right (- (vector-length nums) 1))
             (ans '()))
    (if (< left right)
        (let* ((y (vector-ref nums left))
               (z (vector-ref nums right))
               (sum (+ y z))
               (neg-x (- x)))
          (cond
           ((> sum neg-x) (loop left (- right 1) ans))
           ((< sum neg-x) (loop (+ left 1) right ans))
           (else (loop (+ left 1)
                       (- right 1)
                       (cons (list y z) ans)))))
        ans)))

將返回值改造下，返回xyz：

(define (find-x-y-z nums x)
  (let loop ((left 0)
             (right (- (vector-length nums) 1))
             (ans '()))
    (if (< left right)
        (let* ((y (vector-ref nums left))
               (z (vector-ref nums right))
               (sum (+ y z))
               (neg-x (- x)))
          (cond
           ((> sum neg-x) (loop left (- right 1) ans))
           ((< sum neg-x) (loop (+ left 1) right ans))
           (else (loop (+ left 1)
                       (- right 1)
                       (cons (list x y z) ans)))))
        ans)))

但是還要處理去重，如果遍歷nums，應該要跳過重複的x，雙指針的左端點也不應該每次都從0開始了

(define (find-x-y-z nums x start)
  (let loop ((left start)
             (right (- (vector-length nums) 1))
             (ans '()))
    (if (< left right)
        (let* ((y (vector-ref nums left))
               (z (vector-ref nums right))
               (sum (+ y z))
               (neg-x (- x)))
          (cond
           ((> sum neg-x) (loop left (- right 1) ans))
           ((< sum neg-x) (loop (+ left 1) right ans))
           (else (loop (+ left 1)
                       (- right 1)
                       (cons (list x y z) ans)))))
        ans)))

(define (three-sum nums)
  (let ((len (vector-length nums))
        (sorted (sort nums <)))
    (let loop ((i 0)
               (result '()))
      (if (< i len)
          (if (and (> i 0)
                   (eq? (vector-ref sorted i)
                        (vector-ref sorted (- i 1))))
              (loop (+ i 1) result)
              (let ((new-ans (find-x-y-z sorted
                                         (vector-ref sorted i)
                                         (+ i 1))))
                (loop (+ i 1)
                      (append result new-ans))))
          result))))

提交后没有通过，因为只跳过了重复的x，下面是最终代码：

(define (find-x-y-z nums x start end)
  (let loop ((left start)
             (right end)
             (ans '()))
    (if (< left right)
        (let* ((y (vector-ref nums left))
               (z (vector-ref nums right))
               (sum (+ y z))
               (neg-x (- x)))
          (cond
           ((and (> left start)
                 (eq? (vector-ref nums (- left 1)) y))
            (loop (+ left 1) right ans))
           ((and (< right end)
                 (eq? (vector-ref nums (+ right 1)) z))
            (loop left (- right 1) ans))
           ((> sum neg-x) (loop left (- right 1) ans))
           ((< sum neg-x) (loop (+ left 1) right ans))
           (else (loop (+ left 1)
                       (- right 1)
                       (cons (list x y z) ans)))))
        ans)))

(define (three-sum nums)
  (let ((len (vector-length nums))
        (sorted (sort nums <)))
    (let loop ((i 0)
               (result '()))
      (if (< i len)
          (if (and (> i 0)
                   (eq? (vector-ref sorted i)
                        (vector-ref sorted (- i 1))))
              (loop (+ i 1) result)
              (let ((new-ans (find-x-y-z sorted
                                         (vector-ref sorted i)
                                         (+ i 1)
                                         (- len 1))))
                (loop (+ i 1)
                      (append result new-ans))))
          result))))

還能做一些優化，按升序排序後，如果xyz和大於0了，後面的數再相加只會更大，可以直接跳出循環過程，但算法時間複雜度​O(N^2)​不能再優化了。

16. 最接近的三数之和#

在求解过程中要维护一个表示最小差距的变量：

(define (three-sum-closest nums target)
  (let ((len (vector-length nums))
        (sorted (sort nums <))
        (answer +inf.0)
        (min-gap +inf.0))
    (let outer-loop ((i 0))
      (when (< i len)
        ;; 跳过重复的i
        (if (and (> i 0)
                 (eq? (vector-ref sorted i)
                      (vector-ref sorted (- i 1))))
            (outer-loop (+ i 1))
            (let ((x (vector-ref sorted i)))
              (let inner-loop ((j (+ i 1))
                               (k (- len 1)))
                (when (< j k)
                  (let* ((y (vector-ref sorted j))
                         (z (vector-ref sorted k))
                         (sum (+ x y z))
                         (gap (abs (- sum target))))
                    ;; 差距更小，更新答案
                    (when (< gap min-gap)
                      (set! min-gap gap)
                      (set! answer sum))
                    (cond
                     ((< sum target)
                      (let loop ((new-j (+ j 1)))
                        ;; 跳过重复
                        (if (and (< new-j k)
                                 (eq? (vector-ref sorted new-j)
                                      (vector-ref sorted j)))
                            (loop (+ new-j 1))
                            (inner-loop new-j k))))
                     ((> sum target)
                      (let loop ((new-k (- k 1)))
                        ;; 跳过重复
                        (if (and (> new-k j)
                                 (eq? (vector-ref sorted new-k)
                                      (vector-ref sorted k)))
                            (loop (- new-k 1))
                            (inner-loop j new-k))))
                     (else
                      (set! answer sum)
                      (set! min-gap 0))))))
              (outer-loop (+ i 1))))))
    answer))

923. 三数之和的多种可能#

题目要求最后答案要做模运算，先定义要模的常量：

(define MOD 1000000007)

和三数之和比，不用去重，但是要想出怎么算所有的可能。

假设按求三数之和的方法，固定第一个数，双指针刚刚找到了满足条件的两个数，这时有两种情况：

1. 两个数相等，由于已经排序了，说明双指针之间所有数都一样，可能的组合就是​C(k, 2)​，k是这个数的计数。并且这时双指针循环可以结束，因为中间没有不同的数了。
2. 两个数不相等，设区间内和左指针下数相同的有m个，和右指针下数相同的有n个，那就是从m中取1个，再从n中取1个，有m * n种组合。另外在区间中间，可能还有符合条件的其它数，所以双指针循环还要继续。

第一种情况可以直接跳出双指针循环，第二种情况需要两边分别计数，先为第二种情况写一个函数：

(define (count-rest-two arr left right)
  (let ((a (vector-ref arr left))
        (b (vector-ref arr right)))
    (let loop ((start (+ left 1))
               (end (- right 1))
               (l-count 1)
               (r-count 1))
      (if (<= start end)
          (cond
           ((eq? a (vector-ref arr start))
            (loop (+ start 1)
                  end
                  (+ l-count 1)
                  r-count))
           ((eq? b (vector-ref arr end))
            (loop start
                  (- end 1)
                  l-count
                  (+ r-count 1)))
           (else (* l-count r-count)))
          (* l-count r-count)))))

注意这里在一个循环过程中求两边计数，最后左右指针相遇时，指针下的数可能刚好和前一个相同，如果用小于判断出循环，结果就不对了。也可以把这个函数写成两边分别循环求计数。

考虑到计算完在双指针中间可能还有解，可以把计数完后双指针的位置也返回出来用于下一次双指针过程，稍作修改：

(use-modules (srfi srfi-11))

(define (count-rest-two arr left right)
  (let ((a (vector-ref arr left))
        (b (vector-ref arr right)))
    (let loop ((start (+ left 1))
               (end (- right 1))
               (l-count 1)
               (r-count 1))
      (if (<= start end)
          (cond
           ((eq? a (vector-ref arr start))
            (loop (+ start 1)
                  end
                  (+ l-count 1)
                  r-count))
           ((eq? b (vector-ref arr end))
            (loop start
                  (- end 1)
                  l-count
                  (+ r-count 1)))
           (else (values start end (* l-count r-count))))
          (values start end (* l-count r-count))))))

(define (three-sum-multi arr target)
  (let ((len (vector-length arr))
        (sorted (sort arr <)))
    (let outer-loop ((i 0)
                     (ans 0))
      (if (< i (- len 2))
          (let loop ((left (+ i 1))
                     (right (- len 1))
                     (ans ans))
            (if (< left right)
                (let ((sum (+ (vector-ref sorted i)
                              (vector-ref sorted left)
                              (vector-ref sorted right))))
                  (cond
                   ((> sum target) (loop left (- right 1) ans))
                   ((< sum target) (loop (+ left 1) right ans))
                   (else
                    (if (eq? (vector-ref sorted left)
                             (vector-ref sorted right))
                        (let ((count (+ (- right left) 1)))
                          (outer-loop (+ i 1)
                                      (+ ans
                                         (quotient (* count (- count 1)) 2))))
                        (let-values (((new-left new-right new-count) (count-rest-two sorted left right)))
                          (loop new-left
                                new-right
                                (+ ans new-count)))))))
                (outer-loop (+ i 1) ans)))
          (modulo ans MOD)))))

344. 反转字符串#

先来一道送分题，只要在数组的头尾各放一个指针，交换指针下的元素，之后两个指针同时向中心移动就可以反转数组了。

如果数组元素个数是单数，那么中间的元素不用处理；如果是偶数个元素，两个指针分别在中间两个元素上做最后一次交换就可以停止，所以循环条件是​left < right​：

def reverse_string(s):
    left = 0
    right = len(s) - 1
    while left < right:
        temp = s[left]
        s[left] = s[right]
        s[right] = temp
        left += 1
        right -= 1

交换的部分使用的是通用写法，要利用Python的特性可以直接用​x, y = y, x​的交换写法。

345. 反转字符串中的元音字母#

送分题结束，再来一首热身题。本题实际只需要在上一题的基础上，额外做一个是否是元音的判断，只有两个指针下都是元音才交换字符。

def reverse_vowels(s):
    l, r = 0, len(s) - 1
    # python不能直接改字符串，所以先转成列表
    chars = list(s)
    vowels = set('aeiouAEIOU')

    while l < r:
        if s[l] not in vowels:
            l += 1
        elif s[r] not in vowels:
            r -= 1
        else:
            # 都是元音，交换  
            chars[l], chars[r] = chars[r], chars[l]
            l += 1
            r -= 1

    return ''.join(chars)

1750. 删除字符串两端相同字符后的最短长度#

根据题目要求，循环条件需要加上左右指针下字符相同。内部可以用子循环，只要字符相同就一直移动指针，最后右指针减左指针加一就是剩余长度了。

def minimum_length(s):
    left, right = 0, len(s) - 1
    while left < right and s[left] == s[right]:
        c = s[left]
        while left <= right and s[left] == c:
            left += 1
        while left <= right and s[right] == c:
            right -= 1
    return right - left + 1

2105. 给植物浇水 II#

这一题直接按着题目描述模拟就可以了。

def minimum_refill(plants, capacity_a, capacity_b):
    ans = 0

    # a b 当前水量
    a = capacity_a
    b = capacity_b

    # a b 当前位置
    left = 0
    right = len(plants) - 1

    while left < right:
        # a的水不够，补充水，答案加1
        if a < plants[left]:
            a = capacity_a
            ans += 1
        # a浇水，右移
        a -= plants[left]
        left += 1

        # b的水不够，补水，答案加1
        if b < plants[right]:
            b = capacity_b
            ans += 1
        # b浇水，左移
        b -= plants[right]
        right -= 1

    # a b 相遇，如果水不够答案再加1
    if left == right and max(a, b) < plants[left]:
        ans += 1
    return ans

977. 有序数组的平方#

最简单的方式就是直接map平方再排序（有负数，必需再排序一次），但是题目既然提了数组是有序的，最好要利用上这个性质。

因为数组本身是非递减的，数组的负数部分的平方就是非递增的，而非负数部分的平方就是非递减的了。如果能找出数组中负数和非负数的分界，从这里开始用两个指针分别指向负数和非负数部分，每次把平方较小的推入结果数组中，之后移动指针就可以解决问题。

先写一个函数用二分查找来找分界点（这里也是利用数组有序的特性）：

import bisect

def find_boundary(nums):
    first_non_negative = bisect.bisect_left(nums, 0)
    return first_non_negative - 1, first_non_negative

用i、j两个指针分别指向最后的负数和第一个非负数（没有负数也没关系，i初始化在-1，相当于单向遍历了）：

def sorted_squares(nums):
    i, j = find_boundary(nums)
    ans = []
    while i >= 0 or j < len(nums):
        # 先处理两个边界情况
        if i < 0:
            ans.append(nums[j] ** 2)
            j += 1
        elif j == len(nums):
            ans.append(nums[i] ** 2)
            i -= 1
        else:
            x = nums[i] ** 2
            y = nums[j] ** 2
            # 小的先进，i向左移，j向右移
            if x < y:
                ans.append(x)
                i -= 1
            else:
                ans.append(y)
                j += 1
    return ans

思路二#

如果把双指针分别放在数组开头和结尾，根据原数组的非递减特性，求平方后最大的数，不是在开头（有负数的情况）就是在结尾。那么先初始化一个和原数组等长的答案数组，从答案数组的末尾向开头遍历，每次比较原数组的开头和结尾平方的大小，就可以做归并排序，从右往左、从大到小更新答案。

def sorted_squares(nums):
    n = len(nums)
    ans = [0] * n
    left, right = 0, n - 1

    # 倒着更新
    for i in range(n - 1, -1, -1):
        l_square = nums[left] ** 2
        r_square = nums[right] ** 2
        # 每次将较大的更新进答案
        if l_square > r_square:
            ans[i] = l_square
            # 左边大就右移左指针，否则就左移右指针
            left += 1
        else:
            ans[i] = r_square
            right -= 1
    return ans

在循环过程中，还可以利用原数组有序的特性，省略重复的平方运算，比如比较​abs(nums[left]) > nums[right]​，或者​-nums[left] > nums[right]​。

948. 令牌放置#

直觉上，应该用最小的能量换分，直到能量不够，用分数换最大的能量。

尝试先从小到大排序令牌，再用相向双指针，能量够就从左边最小的令牌换分，能量不够就从右边最大的令牌换能量。

def bag_of_tokens_score(tokens, power):
    tokens.sort()
    score = 0
    left, right = 0, len(tokens) - 1
    while left <= right:
        # 能量足够，换取分数
        if power >= tokens[left]:
            power -= tokens[left]
            left += 1
            score += 1
        # 能量不够，兑换能量
        elif score > 0:
            power += tokens[right]
            right -= 1
            score -= 1
        # 能量和分数都不足，直接退出
        else:
            break
    return score

思路没感觉有问题，但是在测试用例​[200, 100]​上出错了，答案应该是1，但输出结果是0。仔细想想是因为在我的代码里只要分数足够而能量不足，就会消耗分数去换能量，但是没有考虑到如果兑换完能量后剩下的能量还是不够换分，那就白白亏掉了一分。

再次确认下用积分换能量的条件：

1. 当前能量小于左侧最小令牌，无法消耗能量得分
2. 当前分数大于0
3. 当前能量加上最左侧令牌能量大于等于右侧令牌（这样至少不会亏）
4. 左右指针不能在同一个位置（一个令牌只能用一次）

用代码表示：

def bag_of_tokens_score(tokens, power):
    tokens.sort()
    score = 0
    left, right = 0, len(tokens) - 1
    while left <= right:
        # 能量足够，换取分数
        if power >= tokens[left]:
            power -= tokens[left]
            left += 1
            score += 1
        # 能量不够，兑换能量，但要兑换后还能再获得分数
        elif score > 0 and right > left and (power + tokens[right]) >= tokens[left]:
            power += tokens[right]
            right -= 1
            score -= 1
        # 能量和分数都不足，直接退出
        else:
            break
    return score

和上一篇中介紹的定長滑動窗口不同，本題沒有說要找一個特定長度的子數組，如果要暴力遍歷所有可能的子數組，算法時間複雜度將爲​O(n^2)​。能否將之前提到的三步走套用到這個問題上呢？

不妨先跟着例子​[4,2,4,5,6]​看下，我用括號表示窗口，嘗試只移動右指針增大窗口，用ans表示最大的符合條件的子數組長度：

(4) 2 4 5 6 這個窗口表示的子數組是符合元素不重複的條件的，ans更新爲1

(4 2) 4 5 6 子數組[4, 2]仍然符合條件，ans更新爲2

(4 2 4) 5 6 現在窗口內包含重複數字了

在這裏停下，思考一下，如果在這左指針依然不動，顯然，再移動右指針得到的子數組還是不符合條件的。換句話說，當左指針不動，而右指針移動到一個位置使得題目要求的條件不滿足時，所有以當前左指針開始，右端在當前右指針之後的子數組也同時全部被排除了！既然排除了繼續移動右指針的必要，現在來試試移動左指針吧。

4 (2 4) 5 6 現在窗口符合條件了，再移動右指針試試

4 (2 4 5) 6 仍然符合條件，ans更新爲3

4 (2 4 5 6) 符合條件，ans更新爲4，右指針已經不能再動了，而再移動左指針得到的子數組只會更短，因此4就是最終答案

我將這類問題總結爲兩步：

1. 移動右指針，更新某個狀態，如果滿足條件更新答案，如果不滿足條件，執行步驟2
2. 移動左指針，更新某個狀態，如果滿足條件，執行步驟1，如果不滿足，重複步驟2

這種邏輯適合用命令式寫法表達，這裏用Python來演示：

class Solution:
    def maximumUniqueSubarray(self, nums: List[int]) -> int:
        # 用set來記錄是否重複
        record = set()

        left = 0

        # 窗口內的和
        s = 0
        ans = 0

        # 實際上for i in nums就可以，這裏只是爲了清楚表示左右指針，用了right索引
        for right in range(len(nums)):
            current = nums[right]
            # 當前右指針下值出現在record，說明有重複了
            while current in record:
                # 移動左指針，更新狀態
                record.remove(nums[left])
                s -= nums[left]
                left += 1
            # 更新狀態，更新答案
            record.add(current)
            s += current
            ans = max(ans, s)
        return ans

3. 无重复字符的最长子串#

試着代入上一題所用的兩步，首先還是得有個狀態變量記錄是否有重複，這裏仍然用​set​，還有答案要求的是窗口長，可以用​right - left + 1​來算。

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:
        ans = left = 0
        record = set()

        for right, c in enumerate(s):
            # 出現重複
            while c in record:
                # 更新狀態，移左指針
                record.remove(s[left])
                left += 1

            # 沒有重複，移右指針，更新record
            record.add(c)  # 加入 c

            # 更新答案
            ans = max(ans, right - left + 1)

        return ans

但是只是針對這一題，可以想一想，當右側進窗口，出現重複時，說明必然是這個新進入窗口的字符和前面窗口內相同的字符重複了，那麼是否可以用一個表記錄窗口內每一個字符上一次出現的位置，出現重複時，左指針不就可以直接移動到重複字符上次出現位置的右邊了嗎？

(define (length-of-longest-substring s)
  ;; 題目規定了字符完全在ASCII範圍內，所以可以用128位的數組來記錄
  (let ((last-seen (make-vector 128 -1))
        (len (string-length s)))
    (let loop ((left 0)
               (right 0)
               (ans 0))
      (if (< right len)
          (let* ((current-char (string-ref s right))
                 ;; 字符轉成ASCII碼
                 (char-ascii (char->integer current-char))
                 (char-last-index (vector-ref last-seen char-ascii))
                 ;; 如果有重複，左指針可以一步到位移動到重複字符後面
                 (new-left (max left (+ char-last-index 1))))
            ;; 右入窗口，更新last-seen，更新答案
            (vector-set! last-seen char-ascii right)
            (loop new-left
                  (+ right 1)
                  (max ans (+ (- right new-left) 1))))
          ans))))

1493. 删掉一个元素以后全为 1 的最长子数组#

這一題就是要找一個最長的，最多有一個0的子數組，返回這個子數組長度減一。 狀態量可以是窗口內零的計數，不超過1時，移動右指針，否則移動左指針。

class Solution:
    def longestSubarray(self, nums: List[int]) -> int:
        ans = count = left = 0
        for right, x in enumerate(nums):
            # 移右，更新計數
            if x == 0:
                count += 1
            while count > 1:
                # 不滿足條件，移左，更新計數
                count -= (1 if nums[left] == 0 else 0)
                left += 1
            ans = max(ans, right - left)
        return ans

由於這一題要求是要麼有一個零，要麼沒有零，如果右指針下出現多餘的零，那麼左指針就要移動到窗口內上一個零的右邊。所以這一題也是可以一步更新左指針的：

(define (longest-subarray nums)
  (let ((len (vector-length nums)))
    (let loop ((last-zero -1) ; 記錄上一次出現0的位置
               (left 0)
               (right 0)
               (ans 0))
      (if (< right len)
          (let* ((current-zero? (eq? (vector-ref nums right) 0))
                 ;; 不符合條件時直接將左指針移到上一次0的右邊去
                 (new-left (if current-zero?
                               (max (+ last-zero 1) left)
                               left)))
            (loop (if current-zero? right last-zero)
                  new-left
                  (+ right 1)
                  (max ans (- right new-left))))
          ans))))

209. 长度最小的子数组#

問題從求符合條件的最長的子數組，變成了求符合條件的最短子數組，但是解題思路其實還是一樣的。只是具體步驟變爲：

1. 移動窗口右指針，更新窗口內和，不滿足條件，重複步驟1，符合條件，執行步驟2
2. 移動左指針，窗口和減去左側值，更新答案（窗口長度），直到不符合條件時再執行步驟1

class Solution:
    def minSubArrayLen(self, target: int, nums: List[int]) -> int:
        n = len(nums)
        impossible = n + 1

        ans = impossible
        s = left = 0

        for right, x in enumerate(nums):
            s += x
            while s >= target:
                ans = min(ans, right - left + 1)
                s -= nums[left]
                left += 1

        return 0 if ans == impossible else ans

題外話，每次求最小值時，都會將答案初始化爲無窮大或一個不可能達到的最大值；求最大值時則反過來初始化爲無窮小，這種特殊值在數學上叫作​單位元​。簡單說這種值和另一個值a做運算，總是得到a。

713. 乘积小于 K 的子数组#

這次要求的是符合條件的子數組數量，思路是一貫的，先移動右指針，窗口积超過了K，移動左指針。當窗口符合條件時，右指針不變，顯然以當窗口左端點右邊直到右端點的任一點做左端點得到的子數組都是符合條件的子數組，也就是說答案就是當前窗口的長度​right - left + 1​。

class Solution:
    def numSubarrayProductLessThanK(self, nums: List[int], k: int) -> int:
        # 排除特殊情況
        if k <= 1:
            return 0

        product = 1
        ans = left = 0
        for right, x in enumerate(nums):
            product *= x
            while product >= k:
                product //= nums[left]
                left += 1
            ans += right - left + 1
        return ans

根據題目要求，需要從字符串s中找出長度爲k的子串中可能包含的最大元音字母數，最容易想到的方法就是依次遍歷所有可能的子字符串，統計每個子字符串的元音數，比較得出最大值。這樣做的時間複雜度是​O(kn)​，有沒有可能做到​O(n)​？

思路#

如圖所示，如果題目要求子串長度是3，如果先遍歷第一個子串“abc”，可以得出這個子串中有一個元音“a”，記錄這個結果；第二個子串是“bci”，再遍歷這個子串，發現最後一個字母“i”是元音，問題出現了，在上一次遍歷中已經知道了前兩個字母“bc”中沒有元音，怎麼節省重複的遍歷？

假設現在剛剛完成第一個子串的遍歷，這時我們得到的答案是1，如果把整個字符串想象成一個滑軌，在這個滑軌上有一個長度（或寬度？）爲3的窗戶，它最右邊是“c”，最左邊是“a”，窗戶內的字符已經統計過，現在將窗戶向右推動一格，最右邊就新加入了字符“i”，而最左邊則離開了字符“a”。

可以發現在第一個子串之後，可以像移動窗戶一樣，窗戶的左右兩端同時向右移動，每次移動，如果右邊是元音，將計數加一，如果左邊是元音，因爲它離開了窗口，所以將計數減一。等到窗口最右邊到了原字符串的末尾就可以停止了。相當於只遍歷一次，時間複雜度爲​O(n)​。

具體到代碼裏，可以用兩個指針表示這個窗口的左右端，滑動窗口的步驟爲：

1. 右邊進窗口：判斷當前右指針指向的字符是否是元音，更新局部計數，右移指針。如果窗口大小不足，重複第1步
2. 更新答案：在本題更新方法是​ans = max(ans, local_count)
3. 左邊出窗口：更新局部計數（是元音，減一，否則不變），左指針右移

代码#

具體用代碼來表示這個過程：

(define (max-vowels s k)
  (define (vowel? c)
    (member c '(#\a #\e #\i #\o #\u)))

  (let loop ((ans 0) ; 答案
             (vowel 0) ; 窗口內的元音計數
             (index 0)) ; 窗口右端
    (if (< index (string-length s))
      (let* ((window-not-full? (< index (- k 1)))
             (current-vowel? (vowel? (string-ref s index)))
             (new-vowel (if current-vowel? (+ vowel 1) vowel)))
        (if window-not-full? ; 檢查窗口是否展開
          (loop ans new-vowel (+ index 1)) ; 窗口未展開，重複第一步
          (loop (max ans new-vowel) ; 更新答案
                ;; 左出，如果左端是元音，需要將窗口內元音計數減一
                (if (vowel? (string-ref s (+ (-  index k) 1)))
                    (- new-vowel 1)
                    new-vowel)
                (+ index 1))))
      ans)))

實際代碼裏可以不用維持兩個指針變量，因爲窗口大小是固定的，右指針減窗口大小再加一就是左指針了。

643. 子数组最大平均数 I#

思路#

完成上一題後，可以試試這一題是否能套進之前滑動窗口的套路中去。另外還有個小技巧，由於k是固定的，要求的是平均值最大，那麼可以不必在每個窗口下求平均值，只要找出最大的窗口和，最後再除以k算平均值就可以。

1. 右進：更新局部和，加上右端值，右移指針。如果窗口大小不足，重複第1步
2. 更新答案：比較窗口內的和與全局最大和，保留更大的一個
3. 左出：窗口和減去左端值，左指針右移

代碼#

(define (find-max-average nums k)
  (let loop ((max-sum -inf.0) ; 全局最大和
             (s 0) ; 窗口內的和
             (i 0)) ; 右指針
    (if (< i (vector-length nums))
        (let ((new-s (+ s (vector-ref nums i)))
              (window-not-full? (< i (- k 1))))
          (if window-not-full?
              (loop max-sum new-s (+ i 1)) ; 窗口未滿
              (loop
               (max max-sum new-s) ; 更新最大和
               (- new-s (vector-ref nums (+ (- i k) 1))) ; 左端點離開窗口
               (+ i 1))))
      (/ max-sum k))))

2379. 得到 K 个黑块的最少涂色次数#

思路#

首先分析題目可知，本質上是要數窗口內字符‘W’的數量，找出最少的窗口。繼續往三步走套：

1. 右進：如果右端是W，更新局部計數，右移指針。如果窗口大小不足，重複第1步
2. 更新答案：比較窗口內的計數和全局計數，保留更小的一個
3. 左出：如果左端是W，局部計數減一，否則不變，左端右移。

代碼#

(define (minimum-recolors blocks k)
  (let loop ((min-w-count +inf.0) ; 初始值設成正無窮，方便比較
             (w-count     0)
             (i           0))
    (if (< i (string-length blocks))
        ;; 右進
        (let ((local-w-count (if (char=? (string-ref blocks i) #\W)
                                 (+ w-count 1)
                                 w-count)))
          (if (< i (- k 1)) ; 判斷窗口大小是否足夠
              (loop min-w-count local-w-count (+ i 1))
              (loop (min min-w-count local-w-count) ; 更新答案
                    ;; 左出
                    (if (char=? (string-ref blocks (+ (- i k) 1)) #\W)
                        (- local-w-count 1)
                        local-w-count)
                    (+ i 1))))
        min-w-count)))

1423. 可获得的最大点数#

思路#

題目要求只能從開頭或末尾取走牌，似乎和固定窗口滑動沒有關係了，但是如果反過來想，那就是要找一個大小爲n-k的定長窗口，窗口內數的和最小，這就相當於是從前後拿走了和最大的牌了。

三步走：

1. 右進：更新局部計數，右移指針。如果窗口大小不足，重複第1步
2. 更新答案：比較窗口內的計數和全局計數，保留更小的一個
3. 左出：局部計數減去左端值，左指針右移。

給讀者一個小挑戰，嘗試獨立寫出代碼

思路二#

在反向思考後，可以再換個思路

考慮所有可能的取法：

• 取前k張牌
• 前k-1個加後1個
• 前k-2個加後2個
• ……
• 前2個加後k-2個
• 前1個加後k-1個
• 後k個

生活中你可能見過那種圓柱浴室，裏面的窗帘可以繞着圈子拉，把題目中的數組想象成首尾相連的軌道，一個k長的窗帘在這個軌道上滑動。但是，第一次展開窗口後，窗口是向“左邊”移動的。

用代碼去描述，可以先求出前k個數的和，從i=1開始枚舉到i=k，每次將當前和增加 cardPoints[n - i] - cardPoints[k - i]

代碼#

(define (max-score cardPoints k)
  (let ((n (vector-length cardPoints))
        (init-sum (let loop ((i 0)
                             (s 0))
                    (if (eq? i k)
                        s
                        (loop (+ i 1) (+ s (vector-ref cardPoints i)))))))
    (let loop ((i 1)
               (cur-sum init-sum)
               (max-sum init-sum))
      (if (> i k)
          max-sum
          (let ((new-sum (+ (- cur-sum (vector-ref cardPoints (- k i)))
                            (vector-ref cardPoints (- n i)))))
            (loop (+ i 1)
                  new-sum
                  (max max-sum new-sum)))))))

2090. 半径为 k 的子数组平均值#

思路#

仍然使用三步走套路，但是要注意窗口大小不是題目中的k，左右指針和k的關係要注意

1. 右進：更新局部和，右移指針。如果窗口大小不足，重複第1步
2. 更新答案：更新到答案數組的​i - k​位
3. 左出：局部計數減去左端值，左指針右移。

代碼#

(define (get-averages nums k)
  (let* ((len (vector-length nums))
         (win-size (+ (* k 2) 1))
         (ans (make-vector len -1)))
    (let loop ((index 0)
               (pre-sum 0))
      (if (< index len)
          (let ((sum (+ pre-sum (vector-ref nums index)))) ; 右側進窗口，記錄和
            (if (< index (* k 2))
                (loop (+ index 1) sum) ; 構建窗口
                (begin
                  (vector-set! ans (- index k) (/ sum win-size)) ; 更新答案
                  (loop (+ index 1)
                        ;; 出窗口
                        (- sum (vector-ref nums (- index (* k 2))))))))
          ans))))

1052. 爱生气的书店老板#

思路#

由題目知，grumpy爲0時，顧客一定滿意，老板使用控制技能，在minutes內不生氣，只會使結果加上grumpy爲1對應的顧客數，那麼如果算出grumpy爲0的顧客數，再滑動窗口，找出grumpy爲1的顧客數最多的窗口，加起來就得到結果。

代碼#

實作可以不用先遍歷一次求在不控制情緒情況下的顧客和，因爲只需要在最後用到這個值，在滑動窗口的同時累加就可以

(define (max-satisfied customers grumpy minutes)
  (let ((len (vector-length customers)))
    (let loop ((origin-sum 0) ; 記錄不控制情緒情況下，滿意顧客數
               (extra-sum 0) ; 記錄控制情緒所能獲得的最大顧客數
               (s 0) ; 當前窗口通過控制情緒可以使其滿意的顧客數
               (i 0))
      (if (< i len)
          ;; 進窗口
          (let* ((angry? (eq? (vector-ref grumpy i) 1))
                 (current-customers (vector-ref customers i))
                 (new-origin-sum (+ origin-sum (if angry? 0 current-customers))) ; 如果沒生氣，更新origin-sum
                 (new-s (+ s (if angry? current-customers 0)))) ; 如果生氣，更新s
            (if (< i (- minutes 1))
                ;; 展開窗口
                (loop new-origin-sum
                      origin-sum
                      new-s
                      (+ i 1))
                (loop new-origin-sum
                      ;; 更新答案
                      (max extra-sum new-s)
                      ;; 出窗口
                      (if (eq? (vector-ref grumpy (+ (- i minutes) 1)) 1)
                          (- new-s (vector-ref customers (+ (- i minutes) 1)))
                          new-s)
                      (+ i 1))))
          (+ origin-sum extra-sum)))))

1652. 拆炸弹#

思路#

這一題乍一看好像不知道怎麼去構建窗口，沒關係，先列出例子中所有的索引，試着找出關係

n = 4, k = 3:

看到循環數組，首先想到應該有模運算，可以發現，

如果把a到c看作一個滑動窗口，按從左往右滑動排序後表格如下：

那在滑動過程中，能從右指針推出應該更新答案的第幾位嗎？可以的，按前面c也就是右指針和i的關係，做逆運算：

再看看題目裏例子三k = -2的情況，是否有不同

n = 4, k = -2

k是負數，但是窗口長度（或寬度）肯定只能是正數2，還是一樣從左往右滑動

因爲題目規定k爲負數時，算當前索引前k個數的和，所以右指針加1就是索引，但注意不能溢出，還是需要模運算：

這樣一來問題就簡單了，除了k等於0時直接返回全0數組，其他情況只要維護一個長爲​abs(k)​的窗口，向右滑動，根據右端點索引和答案索引的關係，去更新相應的答案就可以了。

代碼#

(define (decrypt code k)
  (let* ((n (vector-length code))
         (ans (make-vector n 0))
         (abs-k (abs k)))
    (if (eq? k 0)
        ans ; k等於0直接返回全0數組
        (let loop ((sum 0)
                   (right 0)
                   (left 0))
          (if (< left n)
              ;; 進窗口
              (let ((new-sum(+ sum (vector-ref code (modulo right n)))))
                (if (< right (- abs-k 1))
                    (loop new-sum
                          (+ right 1)
                          left) ; 先展開窗口
                    (begin
                      ;; 更新答案
                      (vector-set! ans
                                   (if (> k 0) ; 根據k和右指針決定更新答案數組哪一位
                                       (modulo (- right k) n)
                                       (modulo (+ right 1) n))
                                   new-sum)
                      ;; 出窗口
                      (loop (- new-sum (vector-ref code left))
                            (+ right 1)
                            (+ left 1)))))
              ans)))))

我使用的環境：

• Emacs 30.2
• macOS 15.4

set-face-attribute的限制#

前面提到，我打算在Emacs中使用Maple Mono NF CN這款中英文2:1等寬的字體，於是我簡單使用了以下配置：

(set-face-attribute 'default nil :font "Maple Mono NF CN" :height 180)

當我打開Emacs，看上去似乎設置成功了，可以當我輸入中文時，卻感覺一陣明顯的卡頓，接着出現的中文字符並不是我所設置的字體的樣子，可是這個字體確實是包含中文字符的，在其他GUI應用中可以驗證這點，問題出在哪呢？

查詢​set-face-attribute​的文檔沒能找到答案，最終在這篇文檔中發現了端倪：

:font

The font used to display the face. Its value should be a font object or a fontset. If it is a font object, it specifies the font to be used by the face for displaying ASCII characters. See Low-Level Font Representation, for information about font objects, font specs, and font entities. See Fontsets, for information about fontsets.

也就是說，如果這個參數不是設置爲一個​fontset​，那麼Emacs只會用指定的字體來顯示​ASCII​字符。在上篇文章中我提到了爲中英文分別設置字體的方法：

(set-face-attribute 'default nil :family "Maple Mono NF" :height 180)
(set-fontset-font t 'han (font-spec :family "LXGW WenKai TC"))

但是當時我以爲這樣設置是將除了​'han​字符集以外的所有字符都用第一個字體顯示，剩下的漢字部分用第二個字體，但是根據前面提到的，這樣使用​set-face-attribute​只會設定ASCII字符而已，驗證這點也很簡單，打開Emacs，輸入一個中文的句號，就會發現惱人的卡頓問題再次出現，並且這個句號沒有使用我所設定的任何一種字體。這也説得過去，因爲中文的標點不在ASCII中，也不在​'han​字符集中。

如果把最初的配置修改成：

(set-face-attribute 'default nil :font "Maple Mono NF CN" :height 180)
(set-fontset-font t 'unicode (font-spec :family "Maple Mono NF CN"))

就能保證中文、英文、標點都使用這款指定的字體顯示了，但是明明這個字體是包含了中文字符的，爲什麼要用這麼麻煩的方式設置？

Fontsets#

A fontset is a list of fonts, each assigned to a range of character codes. An individual font cannot display the whole range of characters that Emacs supports, but a fontset can. Fontsets have names, just as fonts do, and you can use a fontset name in place of a font name when you specify the font for a frame or a face.

從文檔來看，​Fontset​正是爲了解決單個字體不能滿足所有字符顯示的問題而生的，並且每個Fontset都有自已的名字，可以用在所有使用字體名的地方。用​emacs -q​打開Emacs，通過​M-x list-fontsets​可以查看Emacs默認創建的Fontset：

Fontset: -*-*-*-*-*-*-*-*-*-*-*-*-fontset-default
Fontset: -ns-*-*-*-*-*-10-*-*-*-*-*-fontset-standard
Fontset: -*-Menlo-regular-normal-normal-*-*-*-*-*-m-0-fontset-startup

可以在​scratch​下輸入一些文字，用​M-x describe-char​查看字符信息，還可以按下​M-x describe-fontset​獲取當前窗口使用的Fontset詳情。可以發現，只輸入英文字母時，Emacs優先使用了「fontset-startup」中的Menlo字體，但是這個字體裏沒有包含中文字體，所以當輸入中文字符時，就會fallback到另一個字體，在我的系統上，默認是「PingFang」字體。

回顧​set-fontset-font​這個函數，它是用來改變Fontset的主要方法，它的第一個參數就是Fontset名，如果是​t​的話，就等同於​fontset-default​。

(set-fontset-font t 'unicode (font-spec :family "Maple Mono NF CN"))

如果只使用以上一行配置啓動Emacs，會發生什麼呢？答案是：輸入中文字符時的卡頓消失了，因爲直接指定了字體，不用fallback；但是英文字符卻仍然是以​Menlo​字體顯示的，因爲​fontset-default​是最後的後備，​fontset-startup​的優先級更高。

現在可以來說明爲什麼想要用一個包含多種文字的字體卻要兩行代碼配置了：

;; 繞過 `fontset-startup' 使用指定字體顯示ASCII字符
(set-face-attribute 'default nil :font "Maple Mono NF CN" :height 180)
;; 保證其它字符回退至指定字體
(set-fontset-font t 'unicode (font-spec :family "Maple Mono NF CN"))

話說回來，既然Emacs優先使用了​fontset-startup​，那可不可以直接設置這個Fontset？經過測試，是可以的：

(set-fontset-font "fontset-startup" 'unicode (font-spec :family "Maple Mono NF CN" :size 18.0))

自定義Fontset#

當然想要更靈活地使用不同字體，還是需要將​set-face-attribute​和​set-fontset-font​結合起來使用的。前文已經提到，​set-face-attribute​的​:font​參數不一定是字體名，可以用Fontset名來替代，下面以爲​org-mode​的一級標題單獨設置Fontset爲例說明：

;; 創建Fontset
(create-fontset-from-fontset-spec
  (font-xlfd-name
    (font-spec :family "Iosevka Nerd Font"
               :registry "fontset-my"))) ; 這裏名稱必須是 `fontset-xxx' 格式
(set-fontset-font "fontset-my" 'han (font-spec :family "LXGW WenKai Mono TC"))
(set-face-attribute 'org-level-1 nil :fontset "fontset-my" :height 180)

但是要注意，其實按文檔所寫的，將​:font​參數設置爲Fontset名是沒用的，真正能起作用的是文檔中沒有寫的​:fontset​參數。至少在​Emacs 30.2​版本是這樣。

程序員大部分是使用等寬字體的，因爲平時一些容易混淆的如 lI0O 等字符在等寬字體中可以輕易的被分辨出來，而且代碼裏也經常會使用縮進，等寬字體會使多行代碼看起來更美觀。要配置一個全局的等寬字體是最簡單的：

(set-face-attribute 'default nil :family "Maple Mono NF" :height 180)

這個函數的第一個參數被稱爲​FACE​，可以理解爲在Emacs中可以被設置字體、顏色等屬性的單元。按​M-x describe-face​可以查看有不同的FACE的屬性。

方案二：中文特殊字體#

通常一個字體很難滿足所有的需求，Emacs提供了方法對特定字符集設置字體，比如針對漢字設置：

(set-fontset-font t 'han (font-spec :family "LXGW WenKai TC"))

第二個參數也可以是Unicode範圍：

(set-fontset-font t '(#x2ff0 . #x9ffc) (font-spec :family "LXGW WenKai TC"))

方案三：文檔使用非等寬字體#

其實使用方案一可以設置任意全局字體，但是如果想在代碼編輯中使用等寬字體，而在如​org-mode​等文檔中使用非等寬的更適合閱讀的字體，可以這樣做：

(set-face-attribute 'default nil :family "默認字體" :height 180)
(set-face-attribute 'variable-pitch nil :family "非等寬字體，如Helvetica")
(set-face-attribute 'fixed-pitch nil :family "等寬字體，如Maple Mono NF")

設置多套方案，之後可以通過​hook​功能在特定mode下啓用​variable-pitch-mode​：

;; 在 `org-mode' 內使用非等寬字體
(add-hook 'org-mode-hook (lambda () (variable-pitch-mode t)))

方案四：單獨face配置#

在方案一說過，​set-face-attribute​這個函數可以針對不同的face設置樣式（不僅僅是字體），例如在​org-mode​中，​table​模塊具有自動對齊功能，但是這個對齊是通過文本的空格來對齊的，如果設置的字體不是每個字符都等寬或者有合理的比例（如中英文2:1）的話，表格顯示就會很難看了。那能否只給表格設置一個中英文2:1的字體呢？可以這樣實現：

(set-face-attribute 'org-table nil :family "LXGW WenKai Mono TC")

一些主題如​modus​提供混合字體支持，只需按方案三配置​fixed-pitch​，主題會自動將其應用到​org-mode​的表格和代碼塊等需要等寬字體的地方，其它部分可以保持使用非等寬字體。

方案五：face-remap-add-relative#

現在一些字體會支持很多特性，如連字符、自帶​nerdfont​支持、中英文等寬等，也許在大多數場景下都夠用了，只在一些特殊情況下——如在中文筆記裏使用一個對中文顯示更美觀的等寬字體，就可以使用​face-remap-add-relative​：

(set-face-attribute 'default nil :height 180 :family "Maple Mono NF")
(add-hook 'org-mode-hook (lambda () (face-remap-add-relative 'default :family "LXGW WenKai Mono TC")))

總結#

以下幾個方案只是根據我認爲有可能的需求（主要是中文用戶的需求）簡單列了一下，實際使用中可以根據需要組合。

最後還有一種大道至簡的方法，適用於只需要整體上文字和諧的用戶：​找一個支持​nerdfont​、支持中英文2:1的字體，只用一種字體。Maple Mono有一個變體就能做到。

#lang racket

(define (product lst)
  (foldl (lambda (item acc)
           (printf "Got ~a\n" item)
           (* item acc))
         1
         lst))

(product '(1 2 3 4 5))

这是一个典型的声明式写法，代码只是向一个高阶函数传递了每一步要做什么、初始值是什么以及要处理的列表，而如何索引、循环的细节都被隐藏了起来。

但是如果列表中包含0（任何数乘0都等于0，结果显然为0），我们希望遇到0时直接停止计算，这种写法就无法满足。首先在Racket中没有语句的概念，也就没法直接用​return​语句直接中止整个函数；另外由于计算过程在一个​lambda​中，一般的命令式语言也无法直接在其中中断外部函数，一些语言如​Kotlin¹​为这个场景提供了特殊方法。

那么在Racket中要怎么做？回忆一下求阶乘函数：

(define (fact n)
  (if (<= n 1)
    1
    (* n (fact (- n 1)))))

由于计算列表乘积也相对简单，所以如果不借助高阶函数，也可以直接用递归解决：

(define (product-rec lst)
  (let iter ([lst lst]
             [res 1])
    (match lst
      ['() res]
      [(cons 0 _)
       (println "Got zero!")
       0]
      [(cons x xs)
       (printf "Got ~a\n" x)
       (iter xs (* x res))])))

那为什么递归程序可以做到提前停止？

回顾一下简易解释器的实现，如果​evaluate​变为​Continuation-passing​风格，如​evaluate 0​这个操作的后续（Continuation）是什么？可以认为是什么也不做或打印到控制台，我们可以把这个称为​最终后续​。再来看看函数调用表达式，​(evaluate '(foo 1 2) env)​，整个求值步骤是先对​foo​求值，后续是对参数求值，最后取出环境中的函数体，对函数体求值，之后就是最终后续（打印结果）了。

可以发现，从解释器的核心​evaluate​函数的Continuation角度来看，前面的递归程序可以提前终止的原因就是，它暗示了解释器应当在遇到0时，直接使用最终后续。

first-class continuation#

在1960年代，有人提出「functions as first-class citizens」概念，表示在编程语言中函数和一般数据类型享有同等地位，例如被当做参数传递或被另一个函数当做返回值，后来这种特性常被称作「first-class function」。

而在Racket中，不仅有「first-class function」，还有「first-class continuation」。这意味着在Racket代码中可以获取continuation，并将其当做数据来处理。前面提到解释器在解释表达式时，有一个「最终后续」，如打印求值结果到，如果可以在代码中直接「调用」这个continuation，不就能实现不论当前在多深的嵌套回调中，都可以直接让整个解释过程终止吗？

Racket提供了这样一个函数，叫作​call/cc​，全名是​call-with-current-continuation​，这个函数接受一个一元函数f做参数，f函数的参数就是「current continuation」。比如这个计算​(+ 3 (* 2 6) 5)​中，​(* 2 6)​的continuation是什么？可以看作是​(lambda (x) (+ 3 x 5))​：

(define k #f)
(+ 3 (call/cc (lambda (cont)
                (set! k cont)
                (* 2 6)))
   5) ;; => 20

以上代码的结果和直接计算​(+ 3 (* 2 6) 5)​没有区别，但是其中使用了​call/cc​并将k设置成了cont。在这个计算后k变成了什么呢？

(k 2) ;; => 10
(k 1) ;; => 9

没错，k正是​(* 2 6)​的continuation，看上去它和​(lambda (x) (+ 3 x 5))​是等价的。

回到开头所说的​product​函数，现在用​call/cc​来改造它：

(define (product lst)
  (call/cc
    (lambda (return)
      (foldl
        (lambda (item acc)
          (cond
            [(zero? item)
             (println "Got zero!")
             (return 0)]
            [else
(printf "Got ~a\n" item)
              (* item acc)]))
        1
        lst))))

(product '(1 2 0 3 4 5))

注意这个​return​，它并不是一般语言中的关键字哦，它只是一个普通的形式参数，在这里它代表整个函数体的continuation。如在​(display (product 8))​中，这个​return​就相当于是​(lambda (x) (display x))​了。通过遇到0时直接调用continuation，就做到了在foldl函数的lambda参数内部提前终止product的执行的效果。

实现call/cc#

这个神奇的​call/cc​函数是如何实现的呢？首先应该将我们的解释器的​evaluate​过程改造成CPS。

第一步，先提取出一个​evaluate-cps​函数，它比原​evaluate​函数多出一个​cont​参数：

(define (evaluate-cps expr env cont)
  (match expr
    ;; TODO
    ))

(define (evaluate expr env)
  (evaluate-cps expr env displayln)) ;; 用displayln做最终延续

现在来逐步完善模式匹配的各个分支，首先是原子表达式部分，只需要简单地包裹上延续函数：

[(? number?) (cont expr)]
[(? boolean?) (cont expr)]
[(? symbol?) (cont (lookup-env env expr))]

接下来是if表达式，首先应该对​cond-expr​部分求值，这个过程的延续是根据求值的结果，决定递归地对​then-expr​还是​else-expr​求值，并且使用整个if表达式的延续做最终的延续。用代码描述如下：

[`(if ,cond-expr ,then-expr ,else-expr)
    (evaluate-cps cond-expr env
                (λ (cond-value)
                    (if cond-value
                        (evaluate-cps then-expr env cont)
                        (evaluate-cps else-expr env cont))))]

定义函数和变量也并不复杂：

[`(define ,name ,val-expr)
    (evaluate-cps val-expr env
     (λ (value)
      (extend-current-frame env name value)
      (cont value)))]
[`(fn (,name ,params ...) ,body ...)
    (let ([func (function params body env)])
    (extend-current-frame env name func)
    (cont func))]

函数调用部分：

[`(,func-expr ,arg-exprs ...)
  (evaluate-cps func-expr env
                (λ (proc)
                  (let loop ([arg-exprs arg-exprs]
                             [arg-vals '()])
                    (if (null? arg-exprs)
                      (cond
                        [(primitives? func-expr)
                         (cont (apply proc (reverse arg-vals)))]
                        [(function? proc)
                         (let ([new-frame (make-frame)])
                           (for ([param (function-params proc)]
                                 [arg (reverse arg-vals)])
                             (extend-frame new-frame param arg))
                           (let ([new-env (extend-env (function-env proc) new-frame)])
                             (evaluate-cps (function-body proc) new-env cont)))]
                        [else (error 'evaluate "not a procedure: ~a" proc)])
                      (evaluate-cps (car arg-exprs) env
                                    (λ (arg-val)
                                    (loop (cdr arg-exprs) (cons arg-val arg-vals))))))))]

以上代码首先对函数名求值，并传递一个循环过程作为continuation，依次对参数求值，将对下一个函数的求值过程作为continuation传递，直到参数用完，最后的continuation是对函数体求值。这里还体现出CPS代码的一个特点，即由于通过参数将后续操作显式传递，开发者可以自由控制求值顺序，比如先求值参数列表，甚至倒着从最后一个参数开始也可以。

最后实现​call/cc​函数，先定义一个结构存放延续：

(struct continuation
  (cont) #:transparent)

遇到​call/cc​调用时将当前延续封装保存：

[`(call/cc ,proc-expr)
  (evaluate-cps proc-expr env
                (λ (proc)
                  (if (function? proc) ;; 判断一下参数类型
                    (letrec ([k (continuation cont)] ;; 存储当前cont
                             [new-frame (extend-frame (make-frame) (car (function-params proc)) k)]
                             [new-env (extend-env (function-env proc) new-frame)])
                      (evaluate-cps (function-body proc) ;; 对参数的函数体求值
                                    new-env
                                    cont))
                      (error 'call/cc "expected a function"))))]

还需要注意​continuation​是一个结构体，为了使它能被当作普通函数调用，还需要做最后一点修改：

[`(,func-expr ,arg-exprs ...)
  (evaluate-cps func-expr env
                (λ (proc)
                  (let loop ([arg-exprs arg-exprs]
                             [arg-vals '()])
                    (if (null? arg-exprs)
                      (cond
                        ;; 省略
                        [(continuation? proc)
                         (if (= (length arg-vals) 1)
                           ((continuation-cont proc) (car arg-vals))
                           (error 'call/cc "continuation expects 1 argument"))]
                        [else (error 'evaluate "not a procedure: ~a" proc)])
                      (evaluate-cps (car arg-exprs) env
                                    (λ (arg-val)
                                    (loop (cdr arg-exprs) (cons arg-val arg-vals))))))))]

为了不帖大段代码，以上只展示了核心部分，完整的代码我放在了GitHub上，并实现了对​lambda​、​set!​等的支持。

问题#

​call/cc​的强大不止于此，你甚至可以用它实现​try-catch​、​generator​和​async/await​等等²。那么它有没有什么缺点呢？

回到最开始演示​call/cc​的代码，乘法计算的continuation被保存到变量k中，那么对于表达式​(k (k (k 2)))​你期待得到什么值呢？似乎应该是26,然而实际上却是10。因为调用​(k 2)​会指使解释器直接应用continuation而丢弃嵌套的外层​(k (k ...))​，这是​call/cc​的第一个问题，虽然它看上去和普通函数没区别，但实际它没法像普通函数那样组合。

另一个问题是使用它的代码阅读起来有点困难，有点反直觉，比如下面这段代码你能一眼看出结果应该是什么吗？

(let ([x (call/cc (lambda (k) k))])
  (x (lambda (ignore) "hi")))

另一个极端的例子是著名的阴阳迷题：

(let* ((yin
         ((lambda (cc) (display #\@) cc) (call-with-current-continuation (lambda (c) c))))
       (yang
         ((lambda (cc) (display #\*) cc) (call-with-current-continuation (lambda (c) c)))))
    (yin yang))

同时还要注意到，每次遇到​call/cc​，我们的解释器都把当前过程的​整个后续​给保存下来了³，虽然前面提到能借助它实现生成器、协程等，但实际上效率堪忧。

Footnotes:#

为了方便引入后续要介绍的概念，本文先使用Racket写一个简易的mini Lisp解释器，目标是做到支持递归的阶乘计算为止。

从eval开始#

首先来定义核心的eval函数：

#lang racket

(define (evaluate expr)
  (match expr
    [(? number?) expr]
    [(? boolean?) expr]))

(evaluate '42)
(evaluate '#f)

这当然还是非常小儿科的代码，只能原封不动地吐出数值类型和布尔类型的字面量。下面加上对变量的支持：

(define (make-environment)
  (make-hash))

(define (lookup-env env symbol)
  (hash-ref
    env
    symbol
    (λ () (error 'evaluate "failed to find symbol: ~a" symbol))))

这是一个简单的实现，只是封装了哈希表来模拟一个全局的「环境」，用来存储「符号」与其对应的值，接下来修改​evaluate​函数：

(define (evaluate expr env)
  (match expr
    [(? number?) expr]
    [(? boolean?) expr]
    [(? symbol?) (lookup-env env expr)]))

现在可以定义一个全局环境并测试：

(define env (make-environment))

(evaluate 'year env)

但是这段代码会报错，因为现在的​env​是空的，现在需要提供一个自定义变量的机制，让我们为这个mini Lisp添加第一个内置函数吧。

(define (evaluate expr env)
  (match expr
    [(? number?) expr]
    [(? boolean?) expr]
    [(? symbol?) (lookup-env env expr)]
    ;; 支持使用(define name value)来定义变量
    [`(define ,name ,val-expr)
      (let ([value (evaluate val-expr env)])
        (hash-set! env name value)
        value)]))

实现非常简单，当遇到​(define name val-expr)​形式的代码时，首先递归调用​evaluate​对​val-expr​求值，再加结果写入​env​中。

测试：

(evaluate '(define year 2025) env)
(evaluate 'year env) ;; 2025

现在不会报错了。

if#

因为我们要定义的mini Lisp是严格求值的，所以需要在解释器中内置if机制：

[`(if ,cond-expr ,then-expr ,else-expr)
  (if (evaluate cond-expr env)
    (evaluate then-expr env)
    (evaluate else-expr env))]

同样是递归地先对条件表达式求值，再根据结果决定对then还是else表达式求值。

测试：

(evaluate '(define foo #t) env)
(evaluate '(if foo 1 0) env) ;; 输出1

函数#

下一步来支持函数定义和调用：

如果遇到​(fn (foo param) body)​，可以生成一个lambda，并用函数名foo作键存入env中。

[`(fn (,name ,params ...) ,body)
  (let ([proc (λ args
                (for ([param params]
                      [arg args])
                  (extend-environment env param arg))
                (evaluate body env))])
    (hash-set! env name proc)
    proc)]

最后当遇到函数调用时，需要将分别函数名以及所有参数求值，利用​apply​应用过程。

[`(,func ,args ...)
  (let ([proc (evaluate func env)]
        [arg-vals (map (λ (arg) (evaluate arg env)) args)])
    (if (procedure? proc)
      (apply proc arg-vals)
      (error 'evaluate "not a procedure: ~a" proc)))]

需要注意的是，这一段代码必需放在整个模式匹配的末尾（因为前面定义函数、if等都是这个函数调用形式的特殊情况）。

现在可以测试定义并调用函数了：

(evaluate '(fn (foo a b c) b) env)
(evaluate '(foo 4 8 3) env) ;; 8
(evaluate 'a env) ;; 4

定义和调用看上去没什么问题，但是测试代码中的最后一行​(evaluate 'a env)​居然得到结果为4，这是因为当前所有符号都是记录在一个全局的env中的，这并不是正常语言期望得到的结果。

作用域#

为了解决以上问题，需要对环境处理以及函数定义做些改造。

(define (make-base-environment)
  (list primitives))

(define (extend-env env frame)
  (cons frame env))

(define make-frame
  make-hash)

(define primitives
  (make-frame `((+ . ,+)
                (- . ,-)
                (* . ,*)
                (/ . ,/)
                (> . ,>)
                (< . ,<)
                (= . ,=))))

(define (extend-current-frame env symbol value)
  (extend-frame (car env) symbol value))

(define (extend-frame frame symbol value)
  (hash-set! frame symbol value))

(define (lookup-env env symbol)
  (let loop ([frames env])
    (cond
      [(null? frames)
       (error 'evaluate "failed to find symbol: ~a" symbol)]
      [(hash-has-key? (car frames) symbol)
       (hash-ref (car frames) symbol)]
      [else (loop (cdr frames))])))

现在将​environment​改造成​frame​组成的栈，那么函数的实参就应该在一个单独的frame中。同时在这个实现中，加入了一个​primitives​，直接借用了Racket的四则运算和比较运算函数，方便后续定义阶乘函数。

(struct function
  (params body env) #:transparent)

(define (evaluate expr env)
  (match expr
    ;; ... 省略
    [`(fn (,name ,params ...) ,body)
      (let ([func (function params body env)])
        (extend-current-frame env name func)
        func)]
    [`(,func ,args ...)
      (let ([proc (evaluate func env)]
            [arg-vals (map (λ (arg) (evaluate arg env)) args)])
        (cond
          [(procedure? proc)
           (apply proc arg-vals)]
          [(function? proc)
           (let ([new-frame (make-frame)])
             (for ([param (function-params proc)]
                   [arg arg-vals])
               (extend-frame new-frame param arg))
             (let ([new-env (extend-env (function-env proc) new-frame)])
               (evaluate (function-body proc) new-env)))]
          [else (error 'evaluate "not a procedure: ~a" proc)]))]))

自定义函数被实现为一个结构体，并且保存了函数定义时的env。同时函数应用部分也就需要区分开内置函数和自定义函数，对函数体求值前，创建新的frame，并依次将所有实际参数绑定到形参上。

测试：

(evaluate '(fn (fact n)
               (if (= n 1)
                 n
                 (* n (fact (- n 1))))) env)
(evaluate '(fact 8) env) ;; 40320

完成！

使用using关键字#

如数据库、文件等IO相关的API，一般需要在合适的时机将资源释放，经常需要写这样的代码：

try {
    db.xxx();
} catch (e) {
    // handle error
} finally {
    db.close();
}

在这个TC39提案里，引入了一个新的关键字​using​，用于简化这个流程，当然现在还没有什么浏览器支持这个特性，而TypeScript 5.2对这个关键字提供了支持（tsc会把它转换成旧语法）。首先需要有一个暴露​[Symbol.dispose]​方法的对象，然后在一个代码块中使用using代替const初始化这个对象。

function createDb() {
  console.log("Open!")

  return {
    fetch: (params: string) => {
      console.log(params)
    },
    [Symbol.dispose]: () => {
      console.log("Close!")
    }
  }
}

{
  using db = createDb()
  db.fetch("select * from table")
}

最后当离开作用域时，该对象的​[Symbol.dispose]​方法就会被自动调用了。

它还有个对应的async版本，需要这么写：

function createAsyncDb() {
  console.log("Open!")

  return {
    fetch: async (params: string) => {
      console.log(params)
    },
    [Symbol.asyncDispose]: async () => {
      console.log("Close!")
    }
  }
}

{
  await using db = createAsyncDb()
  await db.fetch("select * from table")
}

不过我是不认同为了省去一个手动close的操作，引入一个新关键字的，相比之下，Kotlin的use方式我认为更好。

satisfies#

有时会遇到一种情况，如果一个属性的类型是和类型，它的字面量默认不会被推断为字面的类型：

type Foo = Record<string, string | number | undefined>

const foo: Foo = {
  a: "nice"
}

// 这里就会收到类型错误，因为tsc不认为a是字符串类型
// foo.a不被看作string类型，而是string | number | undefined
foo.a.startsWith("n")

如果改写成：

const foo = {
  a: "nice"
} satisfies Foo

就不会再有错误提示了。使用​satisfies​的另一个区别是，它会限制对象初始化后不能拓展属性：

const foo = {
  hello: "nice"
} satisfies Foo


// 错误
foo.past = 1

const bar: Foo = {
  hello: "nice"
}

// 没问题
bar.past = 1

同时它还可以和​as const​一起用：

const foo = {
  hello: "nice",
  bar: 3,
} as const satisfies Foo

// Cannot assign to 'hello' because it is a read-only property.
foo.hello = 1

val listener = object : ISomeInfoListener {
    override fun onInfoUpdate(info: Info) {
    }
}

SDK.getInstance().registerListener(listener)

SDK.getInstance().unregisterListener(listener)

當多個操作/數據之間存在先後依賴關係時，就容易陷入回調地獄，寫起來非常不舒服。

比如想在導航結束後，收集終點信息，存入數據庫，使用回調的形式寫：

val listener = object : IGuidanceListener {
    override fun onCompleted() {
        val destinationInfoListener = object : IDestinationInfoListener {
            override fun onArrived(info: Info) {
                scope.launch {
                    saveToDb(info)
                }
            }
        }
        SDK.getInstance().registerListener(destinationInfoListener)
    }
}

SDK.getInstance().registerListener(listener)

以上還是高度簡化後的代碼，實際場景下流程更複雜，代碼可讀性很低，修改起來也很麻煩。那麼有沒有辦法把一個回調操作封裝成 suspend ，以同步方式來組織呢？

可以使用 suspendCancellableCoroutine 來做。例如上面的操作，可以轉化爲：

suspend fun getSomeInfo(): Info = suspendCancellableCoroutine { continuation ->
    val listener = object : ISomeInfoListener {
        override fun onInfoUpdate(info: Info) {
            continuation.resume(info)
        }
    }

    SDK.getInstance().registerListener(listener)

    continuation.invokeOnCancellation { SDK.getInstance().unregisterListener(listener) }
}

在我使用的 Kotlin 2.1.0 版本中， continuation.resume 的函數簽名發生了一點變化：

continuation.resume(resourceToResumeWith) { cause, resourceToClose, context ->
    // resourceToResumeWith 和 resourceToClose 實際上是同一個值
    resourceToClose.close()
}

需要傳入一個 onCancellation 的回調，如果resume了一個需要關閉的Resource，可以用這個回調來處理。

CPS全称「Continuation-passing style」，可见这是一种编码的风格，一种传递「Continuation」的风格。那么这个Continuation又是什么呢？用代码来说明，考虑一个求平均值的运算：

(/ (+ 3 5) 2)

将3和5加起来后，再除以2，这个将加法的结果除以2的过程，就是过程​(+ 3 5)​的continuation了，如果直白的翻译就是「后续部分」，用代码表示就是：

(λ (x) (/ x 2))

CPS指的就是将这个后续操作，作为一个显式的参数传递：

(define (add-cps x y cont)
  (cont (+ a b)))

(add-cps x y (λ (x) (/ x 2)))

虽然可能CPS这个名词可能不为广大程序员所熟知，但应该很多程序员都写过这种形式的代码。Continuation表示后续的操作，如在JS中，表示延时1秒后再执行一个操作：

setTimeout(() => {
    console.log("Hello World!")
}, 1000)

将一个匿名函数传递给​setTimeout​，1秒后这个从参数传递的函数会被调用，只是在JS里这个表达后续操作的函数通常被称为​回调函数​，表示并不立即调用而是回头再调用的意思。

CPS变换#

所谓CPS变换，就是将代码转换为CPS这种风格的意思。如这段计算阶乘的代码：

#lang racket

(define (factorial n)
  (if (= n 0)
      1
      (* n (factorial (- n 1)))))

(displayln (factorial 5))

将最后这个打印的操作显式传递，改写函数：

#lang racket

(define (factorial-cps n cont)
  (if (= n 0)
      (cont 1)
      (factorial-cps (- n 1) (λ (result)
                               (cont (* n result))))))

(factorial-cps 5 (λ (result) (displayln result)))
;; 也可以eta化简一下 (factorial-cps 5 displayln)

一个有趣的点是，做了CPS变换后，函数变成了「​尾递归​」的形式。

现在把难度提高一点，如果把阶乘函数内用到的内置函数也做变换呢？

#lang racket

(define (=* a b cont)
  (cont (= a b)))

(define (-* a b cont)
  (cont (- a b)))

(define (** a b cont)
  (cont (* a b)))

(define (factorial-cps n cont)
  (=* n 0 (λ (b)
            (if b
              (cont 1)
              (-* n 1 (λ (n*)
                        (factorial-cps n* (λ (f)
                                            (** n f cont)))))))))

作用管窥#

那么CPS变换究竟有什么作用呢？从前面计算阶乘的代码来看，它似乎只让代码变得更加难读懂了。这一点既是CPS代码的缺点，也是其优点，这实际上是因为程序的控制流程被显式暴露出来了。

再看一个计算斐波那契数的例子：

#lang racket

(define (fib n)
  (cond
    [(= n 0) 0]
    [(= n 1) 1]
    [else (+ (fib (- n 1))
             (fib (- n 2)))]))

(fib 42) ;; 267914296

;; 转换后
(define (=* a b k)
  (k (= a b)))

(define (+* a b k)
  (k (+ a b)))

(define (-* a b k)
  (k (- a b)))

(define (fib* n k)
  (=* n 0
    (λ (k1)
      (if k1
        (k 0)
        (=* n 1
          (λ (k2)
            (if k2
              (k 1)
              (-* n 1
                (λ (k3)
                  (fib* k3
                    (λ (k4)
                      (-* n 2
                        (λ (k5)
                          (fib* k5
                            (λ (k6)
                              (+* k4 k6
                                (λ (k7)
                                  (k k7))))))))))))))))))

可以看到，通过continuation的传递，这里显式地确定了，先计算​n - 1​，再计算​n - 2​，计算顺序是由我们自主控制的；如果把它改成：

(define (fib* n k)
  (=* n 0
    (λ (k1)
      (if k1
        (k 0)
        (=* n 1
          (λ (k2)
            (if k2
              (k 1)
              (-* n 2
                (λ (k3)
                  (fib* k3
                    (λ (k4)
                      (-* n 1
                        (λ (k5)
                          (fib* k5
                            (λ (k6)
                              (+* k4 k6
                                (λ (k7)
                                  (k k7))))))))))))))))))

则改变了运算顺序，结果不变。

利用这种能力，可以在函数式语言中实现一个类似C语言的for循环：

#lang racket

(define (for-loop-cps init cond? update body k)
  (init
    (λ (initial-state)
      (define (loop state)
        (cond?
          state
          (λ (continue?)
            (if continue?
                (body
                  state
                  (λ ()
                    (update
                      state
                      (λ (new-state)
                        (loop new-state)))))
                (k state)))))
      (loop initial-state))))

(define (init-for k)
  (k 0))

(define (cond-for i k)
  (k (< i 10)))

(define (update-for i k)
  (k (+ i 1)))

(define (body-for i k)
  (display "i = ")
  (display i)
  (newline)
  (k))

(for-loop-cps
  init-for
  cond-for
  update-for
  body-for
  (λ (final-state)
    (display "Loop ended. Final i = ")
    (display final-state)))

当然CPS变换的作用不止于此，还可以用它来实现生成器、协程，并且CPS变换的过程也可以通过程序来自动实现，这些内容篇幅较长，以后再单独来展开。