Question

我正在尝试编辑我当前的程序

(define (sumofnumber n)
  (if (= n 0)
      1
      (+ n (sumofnumber (modulo n 2 )))))

这样它返回n个正方形的总和。例如，如果您输入3，程序将执行1 + 4 + 9得到14.我尝试使用模数和其他方法，但它总是进入无限循环。

Answer 1

基本情况不正确（零的平方为零），递归步骤（你为什么采用模数？）和实际操作（你在哪里平算值？）。这就是程序的样子：

(define (sum-of-squares n)
  (if (= n 0)
      0 
      (+ (* n n)
         (sum-of-squares (- n 1)))))

Answer 2

使用合成而不是递归的定义。从下到上阅读程序逻辑的注释：

(define (sum-of-squares n)
  (foldl +                             ; sum the list
         0 
         (map (lambda(x)(* x x))       ; square each number in list
              (map (lambda(x)(+ x 1))  ; correct for range yielding 0...(n - 1)
                   (range n)))))       ; get a list of numbers bounded by n

我提供这个是因为你正在理解递归的习惯。作文是另一个值得探索的Racket习语，经常在教育背景下的递归中被覆盖。

有时我发现组合比递归更容易应用于问题。其他时候，我没有。

Answer 3

你没有对任何东西进行平方，所以没有理由期望它是一个平方和。

使用1 + 4 + 9（n = 3取幂）写下^的结果：

1^2 + 2^2 + 3^2

这是

(sum-of-squares 2) + 3^2

或

(sum-of-squares (- 3 1)) + 3^2

即

(sum-of-squares (- n 1)) + n^2

请注意，模数不会出现在任何地方，也不会将n添加到任何内容中。

（0的平方为0，而不是1。）

Answer 4

您可以将问题分解成小块。
1.创建从1到n的数字列表 2.在列表上映射一个方形函数以对每个数字进行平方 3.应用+以添加平方列表中的所有数字

(define (sum-of-number n)
          (apply + (map (lambda (x) (* x x)) (sequence->list (in-range 1 (+ n 1))))))

> (sum-of-number 3)
    14

Answer 5

这是使用传感器技术的绝佳机会。

计算列表的总和是一个折叠。地图和过滤器也是折叠。以嵌套方式组合多个折叠，如(sum...(filter...(map...sqr...)))，导致多个（此处，三个）列表遍历。

但是when the nested folds are fused, their reducing functions combine in a nested fashion，使用组合缩减函数给我们一个一次遍历折叠：

(define (((mapping  f) kons) x acc) (kons (f x) acc))         ; the "mapping" transducer
(define (((filtering p) kons) x acc) (if (p x) (kons x acc) acc))  ; the "filtering" one

(define (sum-of-positive-squares n) 
  (foldl ((compose (mapping sqr)                        ; ((mapping sqr)
                   (filtering (lambda (x) (> x 0))))    ;    ((filtering {> _ 0})
          +) 0 (range (+ 1 n))))                        ;      +))

; > (sum-of-positive-squares 3)
; 14

当然((compose f g) x)与(f (g x))相同。合并/“组合”（双关语）缩减器函数只需将参数替换为定义即可创建，如

        ((mapping sqr)  ((filtering {> _ 0})  +))
       =
        ( (lambda (kons)
             (lambda (x acc) (kons (sqr x) acc)))
           ((filtering {> _ 0})  +))
       =
        (lambda (x acc)   
           ( ((filtering {> _ 0})  +)
            (sqr x) acc)) 
       =
        (lambda (x acc)   
           ( ( (lambda (kons)
                 (lambda (x acc) (if ({> _ 0} x) (kons x acc) acc)))
               +)
            (sqr x) acc)) 
       =
        (lambda (x acc)   
           ( (lambda (x acc) (if (> x 0) (+ x acc) acc))
            (sqr x) acc)) 
       =
        (lambda (x acc)   
           (let ([x (sqr x)] [acc acc])
             (if (> x 0) (+ x acc) acc)))

几乎看起来像程序员会写的东西。作为练习，

        ((filtering {> _ 0})  ((mapping sqr)  +))
       = 
        ( (lambda (kons)
            (lambda (x acc) (if ({> _ 0} x) (kons x acc) acc)))
         ((mapping sqr)  +))
       = 
        (lambda (x acc) 
          (if (> x 0) (((mapping sqr)  +) x acc) acc))
       = 
        (lambda (x acc) 
          (if (> x 0) (+ (sqr x) acc) acc))

因此，我们不是自己编写融合的reducer函数定义，而是因为每个人类活动都容易出错，我们可以从更原子的“转换”nay 传感器组成这些缩减器函数

在DrRacket工作。

返回正方形的总和

5 个答案: