Scheme函数用于从x向上和向下写入数字

我不确定这句话的最佳表达方式是什么，所以我只想举个例子

（高-低4）->（01 2 3 4 2 1 0）

（高-低0）->（0）

我认为最好的方法是将它分成两个独立的函数，并在主函数中调用它们。上面的代码是函数的第二部分，但我很难定义它的高部分（0-a）

欢迎任何帮助

---

（这不是家庭作业，我只是想了解这个计划是如何运作的）

使用内置列表过程如何？这会容易得多，此外，这是使用Scheme时考虑解决方案的推荐方式，它鼓励函数式编程风格的编码：

(define (high-low n)
  (let ((lst (build-list n identity)))
    (append lst
            (cons n
                  (reverse lst)))))

例如：

(high-low 4)
=> '(0 1 2 3 4 3 2 1 0)

---

使用内置列表过程如何？这会容易得多，此外，这是使用Scheme时考虑解决方案的推荐方式，它鼓励函数式编程风格的编码：

(define (high-low n)
  (let ((lst (build-list n identity)))
    (append lst
            (cons n
                  (reverse lst)))))

例如：

(high-low 4)
=> '(0 1 2 3 4 3 2 1 0)

---

既然你想学习，我想你不想使用很多实用功能，所以我将帮助你学习

高级

。请注意，当您想要构造列表时，有两件事：起始编号和结束编号

对于

low

，这很容易，因为结束数字是一个文本0，而开始数字会发生变化，因此您可以只使用一个变量来跟踪

对于

high

，需要在每次迭代中更改起始编号，如

low

。但是，结束数字不是文字（尽管它是常量），因此我们需要它的信息。因此，我们将添加结束数字作为函数的参数之一。也就是说，我们期望

(high 1 10) ; evaluates to (list 1 2 3 4 5 6 7 8 9 10)

那么，该机构将是：

(define high
  (λ (start stop)
    ...))

终止条件是

start

超过

stop

时。这是基本情况，答案是

”（）

否则，

start

小于或等于

stop

。答案是从

开始

到

停止

结束的列表，与附加到从

（add1 start）

开始到

停止

结束的列表前面的

相同。即:

high start stop = [start start+1 start+2 ... stop] 
                = [start] + [start+1 start+2 start+3 ... stop]
                = [start] + high start+1 stop

因此：

既然你想学习，我想你不想使用很多实用功能，所以我将帮助你学习
高级
。请注意，当您想要构造列表时，有两件事：起始编号和结束编号

对于
low
，这很容易，因为结束数字是一个文本0，而开始数字会发生变化，因此您可以只使用一个变量来跟踪

对于
high
，需要在每次迭代中更改起始编号，如
low
。但是，结束数字不是文字（尽管它是常量），因此我们需要它的信息。因此，我们将添加结束数字作为函数的参数之一。也就是说，我们期望

(high 1 10) ; evaluates to (list 1 2 3 4 5 6 7 8 9 10)

那么，该机构将是：

(define high
  (λ (start stop)
    ...))

终止条件是
start
超过
stop
时。这是基本情况，答案是
”（）

否则，
start
小于或等于
stop
。答案是从
开始
到
停止
结束的列表，与附加到从
（add1 start）
开始到
停止
结束的列表前面的
相同。即:

high start stop = [start start+1 start+2 ... stop] 
                = [start] + [start+1 start+2 start+3 ... stop]
                = [start] + high start+1 stop

因此：

#！球拍
（又名
#lang racket
）有一个
范围
程序，因此如果你手中有球拍的力量，你可以做：

(define (high-low n)
  (append (range n)         ; 0 to n-1
          (range n -1 -1))) ; n to 0

如果你想滚动你自己的递归循环，你可以把它想象成从零开始反向构建一个列表，增加1直到一个极限，然后减少到零。该步骤发生变化，当当前值等于结束值且方向减小时，距离终点线只有一个元素

(define (high-low n)
  (let loop ((cur 0) (limit n) (step add1) (acc '()))
    (cond ((not (= cur limit)) ; general step in either direction
           (loop (step cur) limit step (cons cur acc)))
          ((eq? step add1)     ; turn
           (loop cur 0 sub1 acc))
          (else                ; finished
           (cons cur acc)))))

我想有很多方法可以剥这只猫的皮，而这只是一种方法
 
#！球拍
（又名
#lang racket
）有一个
范围
程序，因此如果你手中有球拍的力量，你可以做：

(define (high-low n)
  (append (range n)         ; 0 to n-1
          (range n -1 -1))) ; n to 0

如果你想滚动你自己的递归循环，你可以把它想象成从零开始反向构建一个列表，增加1直到一个极限，然后减少到零。该步骤发生变化，当当前值等于结束值且方向减小时，距离终点线只有一个元素

(define (high-low n)
  (let loop ((cur 0) (limit n) (step add1) (acc '()))
    (cond ((not (= cur limit)) ; general step in either direction
           (loop (step cur) limit step (cons cur acc)))
          ((eq? step add1)     ; turn
           (loop cur 0 sub1 acc))
          (else                ; finished
           (cons cur acc)))))

我想有很多方法可以剥这只猫的皮，而这只是一种方法
 这里还有几个选项。使用
命名let
和
准引号

(define (high-low n)
  (let hi-lo ((i 0))
    (if (= i n) `(,i) `(,i ,@(hi-lo (+ i 1)) ,i))))

…另一个使用
do
的选项：

(define (high-low2 n)
  (do ((i (- n) (+ i 1))
       (out '() (cons (- n (abs i)) out)))
      ((> i n) out)))

这里还有几个选择。使用
命名let
和
准引号

(define (high-low n)
  (let hi-lo ((i 0))
    (if (= i n) `(,i) `(,i ,@(hi-lo (+ i 1)) ,i))))

…另一个使用
do
的选项：

(define (high-low2 n)
  (do ((i (- n) (+ i 1))
       (out '() (cons (- n (abs i)) out)))
      ((> i n) out)))

这是一个过于通用的解决方案，它基于一个函数，该函数以一种非常通用的方式构建列表。它的优点是尾部递归：它将构建任意长的列表而不会爆炸，但缺点是需要向后构建，并且理解起来有些模糊

以下是函数：

（定义（列表器基inc stop cont）
；从（非空）列表开始，基；
将更多的形式元素（inc（first…）；
直到（停止（首先…）为真；
；最后使用结果列表调用cont
（定义（列表器循环累计）
（如果（停止（第一累计））
（续累积）
（李斯特回路（cons（inc（第一累计））累计）
（列表器循环基）

（请注意，这显然可以将命名let用于内部函数。）

这是一个函数，使用这个函数，两次，向上和向下计数

（定义（cud n）
上下数数
（列表器’（0）
（λ（x）（+x1））
（λ（x）（=xn））
（λ（累计）