加扰功能如何工作？ （《老谋深算》第一章）

Question

根据这本书，这就是函数定义，

函数 scramble 接受一个非空元组，其中没有参数大于它自己的索引，并返回一个相同长度的元组。 参数中的每个数字都被视为从它自己的位置到元组中更早一点的向后索引。 每个位置的结果都是根据这个索引从当前位置倒数得到的。

这些是一些例子，

; Examples of scramble
(scramble '(1 1 1 3 4 2 1 1 9 2))       ; '(1 1 1 1 1 4 1 1 1 9)
(scramble '(1 2 3 4 5 6 7 8 9))         ; '(1 1 1 1 1 1 1 1 1)
(scramble '(1 2 3 1 2 3 4 1 8 2 10))    ; '(1 1 1 1 1 1 1 1 2 8 2)

这是实现，

(define pick
  (λ (i lat)
    (cond
      ((eq? i 1) (car lat))
      (else (pick (sub1 i)
                  (cdr lat))))))

(define scramble-b
  (lambda (tup rev-pre)
    (cond
      ((null? tup) '())
      (else
       (cons (pick (car tup) (cons (car tup) rev-pre))
             (scramble-b (cdr tup)
                         (cons (car tup) rev-pre)))))))

(define scramble
  (lambda (tup)
    (scramble-b tup '())))

Answer 1

在这种情况下，使用非常小的语言版本意味着代码足够冗长，以至于理解算法可能并不容易。

解决这个问题的一种方法是用更丰富的语言编写程序，然后计算出现在很明显的算法是如何在最小版本中实现的。 让我们选择Racket作为丰富的语言。

Racket 有一个名为list-ref的函数（和 Scheme 一样）： (list-ref li)返回l的第i个元素，从零开始。

它还有一个很好的“序列”概念，几乎是“可以迭代的东西”和一堆名称以for开头的结构，用于迭代序列。 有两个函数可以生成我们关心的序列：

• in-naturals生成自然数的无限序列，默认情况下从0开始，但(in-naturals n)从n开始。
• in-list从列表中生成序列（列表实际上已经是序列，但是in-list使事情更清晰，传闻也更快）。

我们关心的迭代结构是for/list ，它迭代一些序列并将结果从它的主体收集到一个列表中。

鉴于这些，算法几乎是微不足道的：我们想要沿着列表进行迭代，跟踪当前索引，然后进行适当的减法以沿着列表往后选择一个值。 唯一重要的一点是处理基于零和一的索引。

(define (scramble l)
  (for/list ([index (in-naturals)]
             [element (in-list l)])
    (list-ref l (+ (- index element) 1))))

事实上，如果我们让in-naturals从1开始计数，我们可以避免尴尬的加 1：

(define (scramble l)
  (for/list ([index (in-naturals 1)]
             (element (in-list l)))
    (list-ref l (- index element))))

现在看这段代码，即使不了解Racket，算法也很清楚，可以查一下书中给出的答案：

> (scramble '(1 1 1 3 4 2 1 1 9 2))
'(1 1 1 1 1 4 1 1 1 9)

现在还有待弄清楚书中的代码如何实现相同的算法。 这很繁琐，但是一旦你知道算法是什么，它应该很简单。

Answer 2

如果口头描述看起来模糊且难以理解，我们可以尝试跟踪代码本身，将其转换为更直观的伪代码：

pick i [x, ...ys] = 
  case i { 
     1 --> x ;
     pick (i-1) ys }
==>
  pick i xs = nth1 i xs
     (* 1 <= i <= |xs| *)

scramble xs = 
   scramble2 xs []

scramble2 xs revPre =
 case xs {
   [] --> [] ;
   [x, ...ys] -->
     [ pick x [x, ...revPre],
       ...scramble2 ys
              [x, ...revPre]] }

因此，

scramble [x,y,z,w, ...] 
 =
  [ nth1 x [x]       (*x=1..1*)
  , nth1 y [y,x]     (*y=1..2*)
  , nth1 z [z,y,x]   (*z=1..3*)
  , nth1 w [w,z,y,x] (*w=1..4*)
  , ... ]

因此，输入列表中的每个元素都用作该列表的反向前缀的索引，直到并包括该元素。 换句话说，在向后计数时，前缀的索引，即从元素到左侧，即朝向列表的开始。

所以我们现在已经可视化了代码在做什么，并且还发现了对其输入列表元素的需求。