Scheme 如何将指数应用于球拍中的内置列表

所以我知道如何在球拍中建立一个列表，使用，建立列表

例如：

(build-list 2 add1) => (list 1 2)

但是如果我想把指数应用到列表中，在列表中以某个数字结尾，我该怎么做呢

例如： 指数3，它将从0开始，在3结束，将其应用于构建列表中的1和2

1^0 * 1^1 * 1^2 * 1^3 
2^0 * 2^1 * 2^2 * 2^3 

大概是我所拥有的

(define (list-of-numbers m n)
(apply * (build-list (get m) (lambda (n) (expt n n)))))

  (define (get m)
    (build-list m add1))

输出应为：

(list-of-numbers 2 3) ⇒ (list 1 64)

1 × 1 × 1 × 1 = 1 
1 × 2 × 4 × 8 = 64

---

对于其中的每一个，都有指数0..3，可以通过

构建列表4

> (build-list 4 (lambda (n) n))
(list 0 1 2 3)

然后可以将

expt

调用放入lambda中

> (build-list 4 (lambda (n) (expt 2 n)))
(list 1 2 4 8)

如果要将列表中的元素相乘，可以使用

apply*

> (apply * (build-list 4 (lambda (n) (expt 2 n))))
64

---

对于其中的每一个，都有指数0..3，可以通过

构建列表4

> (build-list 4 (lambda (n) n))
(list 0 1 2 3)

然后可以将

expt

调用放入lambda中

> (build-list 4 (lambda (n) (expt 2 n)))
(list 1 2 4 8)

如果要将列表中的元素相乘，可以使用

apply*

> (apply * (build-list 4 (lambda (n) (expt 2 n))))
64

---

使用

buildlist

的解决方案可以从构建

m

元素列表开始：

(build-list m add1)

这里，

（构建列表2 add1）

-->

（12）

接下来，可以再次使用

buildlist

在列表上映射

，以构建列表列表。我们需要一个应用于列表的过程，例如从每个元素构造一个列表的
（12）
。请注意，每个元素应转换为
n+1
元素列表（在
数字列表23
的情况下，我们有
n==3
）：

当此过程应用于
（12）
中的元素时，我们应该得到一个类似
（11）
或
（12 4 8）
的列表。为此，将对范围
[0，n]
内的数字调用
某些过程。
某些过程
需要做的是从第一个列表中获取其编号（
x
，在上面的
lambda
表达式中），并将其从第二个列表中提升到其编号的幂次方（范围
[0，n]
）。因此，现在可以将
一些过程编写为：

(lambda (y) (expt x y))

这里，
x
取自第一个
lambda
表达式，
y
取自
[0，n]
范围，该范围由
构建列表提供。现在我们需要在我们构建的第一个列表上映射这个复合表达式：

(map (lambda (x) (build-list (add1 n) (lambda (y) (expt x y))))
     (build-list m add1))

如果我们用输入值2和3分别测试上述映射的结果，对于
m
和
n
，我们将得到：

（（11）（1 2 4 8））

剩下的就是将
乘法应用于这里的子列表；同样，我们可以
map
a
lambda
表达式，该表达式在每个子列表上使用
apply
，给我们留下一个结果列表：

(define (list-of-numbers m n)
  (map (lambda (s) (apply * s))
       (map (lambda (x) (build-list (add1 n) (lambda (y) (expt x y))))
            (build-list m add1))))

以下是一些示例输出：

scratch.rkt>（数字列表2-3）
'(1 64)
scratch.rkt>（数字列表3）
'(1 64 729)
scratch.rkt>（数字列表3 2）
'(1 8 27)

有什么我可以用而不是申请的吗？
除了使用
apply
，还可以使用
map
，使用
lambda
表达式将
foldl
与子列表相乘：

(define (list-of-numbers-2 m n)
  (map (lambda (x) (foldl * 1 x))
       (map (lambda (x) (build-list (add1 n) (lambda (y) (expt x y))))
            (build-list m add1))))

工作原理与之前相同：

scratch.rkt>（数字列表-2-3）
'(1 64)
scratch.rkt>（数字列表-2-3）
'(1 64 729)
scratch.rkt>（数字列表-2）
'(1 8 27)
使用
构建列表的解决方案可以从构建
m
元素列表开始：

(build-list m add1)

这里，
（构建列表2 add1）
-->
（12）

接下来，可以再次使用
buildlist
在列表上映射
，以构建列表列表。我们需要一个应用于列表的过程，例如从每个元素构造一个列表的
（12）
。请注意，每个元素应转换为
n+1
元素列表（在
数字列表23
的情况下，我们有
n==3
）：

当此过程应用于
（12）
中的元素时，我们应该得到一个类似
（11）
或
（12 4 8）
的列表。为此，将对范围
[0，n]
内的数字调用
某些过程。
某些过程
需要做的是从第一个列表中获取其编号（
x
，在上面的
lambda
表达式中），并将其从第二个列表中提升到其编号的幂次方（范围
[0，n]
）。因此，现在可以将
一些过程编写为：

(lambda (y) (expt x y))

这里，
x
取自第一个
lambda
表达式，
y
取自
[0，n]
范围，该范围由
构建列表提供。现在我们需要在我们构建的第一个列表上映射这个复合表达式：

(map (lambda (x) (build-list (add1 n) (lambda (y) (expt x y))))
     (build-list m add1))

如果我们用输入值2和3分别测试上述映射的结果，对于
m
和
n
，我们将得到：

（（11）（1 2 4 8））

剩下的就是将
乘法应用于这里的子列表；同样，我们可以
map
a
lambda
表达式，该表达式在每个子列表上使用
apply
，给我们留下一个结果列表：

(define (list-of-numbers m n)
  (map (lambda (s) (apply * s))
       (map (lambda (x) (build-list (add1 n) (lambda (y) (expt x y))))
            (build-list m add1))))

以下是一些示例输出：

scratch.rkt>（数字列表2-3）
'(1 64)
scratch.rkt>（数字列表3）
'(1 64 729)
scratch.rkt>（数字列表3 2）
'(1 8 27)

有什么我可以用而不是申请的吗？
除了使用
apply
，还可以使用
map
，使用
lambda
表达式将
foldl
与子列表相乘：

(define (list-of-numbers-2 m n)
  (map (lambda (x) (foldl * 1 x))
       (map (lambda (x) (build-list (add1 n) (lambda (y) (expt x y))))
            (build-list m add1))))

工作原理与之前相同：

scratch.rkt>（数字列表-2-3）
'(1 64)
scratch.rkt>（数字列表-2-3）
'(1 64 729)
scratch.rkt>（数字列表-2）
'(1 8 27)
谢谢你，亚历克斯。如果我想让用户输入构建列表和指数的编号，我会怎么做。使用build-l