Recursion 在Dr.Racket中，如果列表中的每个整数都是偶数，那么我如何编写一个Racket函数来生成true，否则生成false？

在Dr.Racket中，我如何编写一个Racket函数，如果列表中的每个整数都是偶数，则生成true，否则生成false。 这是我目前的代码：

(define (everything-is-even? speciallist)
  (cond
    [(even? (first speciallist)) true]
    [(even? (first speciallist)) (everything-is-even? (rest speciallist))]
    [(empty? speciallist) true]
    [else false]))

例如，我输入

(everything-is-even? (cons 2 (cons 6 (cons 9 empty))))

我想要的输出是假的，因为9是奇数。然而，我却得到了一个真实的答案。

---

任何关于如何解决此代码的提示都将非常有用。

您可以使用

和map

(define (everything-pass-test-v2 lon)
  (local [(define (my-and a b) (and a b))]
    (foldr my-and #t (map even? lon))))

(everything-pass-test-v2 '(2 4 6 8 10)) ; #t 
(everything-pass-test-v2 '(2 4 6 8 10 9)) ; #f

我不确定您只想检查所有数字是否为偶数，或者您想检查每个元素是否为偶数或

false

#lang racket
(define (everything-pass-test lon)
  (local [(define (pass? x)
            (if (number? x)
                (even? x)
                (false? x)))]
    (andmap pass? lon)))

(everything-pass-test '(2 4 6 8 10 #t)) ; #f
(everything-pass-test '(2 4 6 8 10 9)) ; #f

如果要检查所有数字是否为偶数或

false

#lang racket
(define (everything-pass-test lon)
  (local [(define (pass? x)
            (if (number? x)
                (even? x)
                (false? x)))]
    (andmap pass? lon)))

(everything-pass-test '(2 4 6 8 10 #t)) ; #f
(everything-pass-test '(2 4 6 8 10 9)) ; #f

若你们想检查所有的数字都是偶数

#lang racket
(define (everything-pass-test lon)
  (andmap even? lon))

(everything-pass-test '(2 4 6 8 10)) ; #t
(everything-pass-test '(2 4 6 8 10 9)) ; #f

或者用这种方式

(define (all-enve? lon)
  (cond
    [(empty? lon) #t]
    [(even? (first lon))
     (all-enve? (rest lon))]
    [else #f]))


(all-enve? '(2 4 6 8 10)) ; #t 
(all-enve? '(2 4 1 6 8 10)) ; #f

或者您可以使用这种方式，它看起来像

和map

(define (everything-pass-test-v2 lon)
  (local [(define (my-and a b) (and a b))]
    (foldr my-and #t (map even? lon))))

(everything-pass-test-v2 '(2 4 6 8 10)) ; #t 
(everything-pass-test-v2 '(2 4 6 8 10 9)) ; #f

---

您可以使用

和map

(define (everything-pass-test-v2 lon)
  (local [(define (my-and a b) (and a b))]
    (foldr my-and #t (map even? lon))))

(everything-pass-test-v2 '(2 4 6 8 10)) ; #t 
(everything-pass-test-v2 '(2 4 6 8 10 9)) ; #f

我不确定您只想检查所有数字是否为偶数，或者您想检查每个元素是否为偶数或

false

#lang racket
(define (everything-pass-test lon)
  (local [(define (pass? x)
            (if (number? x)
                (even? x)
                (false? x)))]
    (andmap pass? lon)))

(everything-pass-test '(2 4 6 8 10 #t)) ; #f
(everything-pass-test '(2 4 6 8 10 9)) ; #f

如果要检查所有数字是否为偶数或

false

#lang racket
(define (everything-pass-test lon)
  (local [(define (pass? x)
            (if (number? x)
                (even? x)
                (false? x)))]
    (andmap pass? lon)))

(everything-pass-test '(2 4 6 8 10 #t)) ; #f
(everything-pass-test '(2 4 6 8 10 9)) ; #f

若你们想检查所有的数字都是偶数

#lang racket
(define (everything-pass-test lon)
  (andmap even? lon))

(everything-pass-test '(2 4 6 8 10)) ; #t
(everything-pass-test '(2 4 6 8 10 9)) ; #f

或者用这种方式

(define (all-enve? lon)
  (cond
    [(empty? lon) #t]
    [(even? (first lon))
     (all-enve? (rest lon))]
    [else #f]))


(all-enve? '(2 4 6 8 10)) ; #t 
(all-enve? '(2 4 1 6 8 10)) ; #f

或者您可以使用这种方式，它看起来像

和map

(define (everything-pass-test-v2 lon)
  (local [(define (my-and a b) (and a b))]
    (foldr my-and #t (map even? lon))))

(everything-pass-test-v2 '(2 4 6 8 10)) ; #t 
(everything-pass-test-v2 '(2 4 6 8 10 9)) ; #f

---

如果需要检查列表中的每一个数字是否为偶数，则由于第一个数字为偶数，因此不能有

true

。由于您已确定结果为

true

，因此它将在此处停止

你知道的是，只有当你到达列表的末尾时，你才知道结果是真的。例如

(everything-is-even? '()) ; ==> #t

您还知道，如果进入下一个

cond

子句，则不会有空列表。如果是这样，第一个元素不是偶数，您知道结果是

#f

，无需进一步研究列表

如果前面的cond子句都没有命中，那么应该有一个

else

子句来检查列表其余部分的

所有内容是否为偶数？

现在，您可以切换最后两个，这样，如果第一个元素是您递归的事件，然后有一个带有#f`的

elsea，但是您需要首先对空列表进行测试，因为当您在第三个项上有空列表时，就像在代码中一样，您已经在窥视可能没有第一个元素的东西的第一个元素

以下是一些例子：

(everything-is-even? '())    ; ==> #t (base case)
(everything-is-even? '(3))   ; ==> #f (base case)
(everything-is-even? '(2))   ; ==> #t (default case leading to (everything-is-even? '()))
(everything-is-even? '(2 3)) ; ==> #f (default case leading to (everything-is-even? '(3)))

如果需要检查列表中的每一个数字是否为偶数，则由于第一个数字为偶数，因此不能有
true
。由于您已确定结果为
true
，因此它将在此处停止

你知道的是，只有当你到达列表的末尾时，你才知道结果是真的。例如

(everything-is-even? '()) ; ==> #t

您还知道，如果进入下一个
cond
子句，则不会有空列表。如果是这样，第一个元素不是偶数，您知道结果是
#f
，无需进一步研究列表

如果前面的cond子句都没有命中，那么应该有一个
else
子句来检查列表其余部分的
所有内容是否为偶数？

现在，您可以切换最后两个，这样，如果第一个元素是您递归的事件，然后有一个带有

#f`的

elsea，但是您需要首先对空列表进行测试，因为当您在第三个项上有空列表时，就像在代码中一样，您已经在窥视可能没有第一个元素的东西的第一个元素

以下是一些例子：

(everything-is-even? '())    ; ==> #t (base case)
(everything-is-even? '(3))   ; ==> #f (base case)
(everything-is-even? '(2))   ; ==> #t (default case leading to (everything-is-even? '()))
(everything-is-even? '(2 3)) ; ==> #f (default case leading to (everything-is-even? '(3)))