我希望能够对列表中偶数元素的平方求和，但是我当前的代码只对元素求和，而不是求平方。有没有人知道可以进行任何修改以使其与列表中偶数值元素的平方相加？
(define (sum elemList)
(if
(null? elemList)
0
(+ (car elemList) (sum (cdr elemList)))
)
)
我的意见是：
(sum-evens (list 1 2 3 4))
输出将是：
20
哪个是(2*2) + (4*4)。
如果可能，最好同时看到递归和迭代解决方案。 有什么想法吗？
答案 0 :(得分：2)
使用Racket的左侧折叠功能，
(define (foldl cons z ls)
(if (null? ls)
z
(foldl cons (cons (car ls) z) ; NB! args order
(cdr ls))))
我们可以轻松地实现列表（(foldl + 0 xs)），或的求和，分别采用正方形，或过滤。
嵌套它们也很容易，因此可以使用另一个的结果（如其他答案中所示），但这意味着执行三个单独的列表遍历，
(define (sqr x) (* x x))
(define (foo-3 xs)
(foldl + 0
(foldl (lambda (x acc) (cons (sqr x) acc)) '()
(foldl (lambda (x acc) (if (even? x) (cons x acc) acc)) '()
xs))))但实际上，折叠（或“减少”）带有 reducer 功能的列表（如 + ）取代该列表的 cons 无论如何都要使用该功能的应用程序，那么为什么不继续使用首先使用该reducer ？这意味着嵌套的折叠可以融合作为
(define (foo-2 xs)
(foldl (lambda (x acc) (+ (sqr x) acc)) 0
(foldl (lambda (x acc) (if (even? x) (cons x acc) acc)) '()
xs)))，而且，作为
(define (foo-1 xs) ; one traversal, tail-recursive, iterative!
(foldl (lambda (x acc) (if (even? x) (+ (sqr x) acc) acc)) 0
xs))因此派生迭代一遍遍函数，否则可以相对容易地手工编码，但作为递归变体（见过）在其他答案）。
我们认为需要在此处对cons进行抽象，以便可以轻松地对其进行操作和替换。换句话说，我们想要
(lambda (x acc) (cons (sqr x) acc)) ==: ((mapping sqr) cons)
(lambda (x acc) (if (even? x) (cons x acc) acc)) ==: ((filtering even?) cons)因此到达所谓的“换能器”，即缩减器函数的修饰符：
(define (((mapping f) kons) x acc) (kons (f x) acc)) ; "mapping" transducer
(define (((filtering p) kons) x acc) (if (p x) (kons x acc) acc)) ; "filtering" one
(define (foo xs)
(foldl + 0
(foldl ((mapping sqr) cons) '()
(foldl ((filtering even?) cons) '()
xs)))
=
(foldl ((mapping sqr) +) 0 ; replace the constructor!
(foldl ((filtering even?) cons) '() ; and the sentinel value
xs))
=
(foldl ((filtering even?) ((mapping sqr) +)) 0 ; and again!
; (lambda (x acc) (if (even? x) (+ (sqr x) acc) acc)) ; look, ma, no cons!
xs)
) (f (g x))模式被抽象为功能组合，
(define ((compose1 f g) x)
(f (g x)))
以便(f (g x))为((compose1 f g) x)。使用更为通用的compose接受任何个组成的函数，
(define ((compose . fs) x)
(if (null? fs)
x
((car fs) ((apply compose (cdr fs)) x))))
我们可以用更一般的方式对它进行编码，然而我们可能需要将许多传感器组合成一个组合传感器，为每个参数执行组合操作（取自输入序列;此处为列表）：
(define (transduce-list tducr op z xs)
(foldl ; lists are reduced with foldl
(tducr op) ; the full reducer is created by applying
z xs)) ; the transducer to the final reducer
(define (foo xs) ; sum the squares of evens in a list
(transduce-list ; by transducing the list
(compose ; with the transducer composed from
(filtering even?) ; a filtering step and
(mapping sqr)) ; a mapping step
+ 0 xs)) ; with + as the final reducer
所以我们有
(define (sqr1 x) (+ 1 (* x x))) ; for clearer testing results
> (foldl ((mapping sqr1) cons) '() '(1 2 3 4))
'(17 10 5 2)
> (foldl ((mapping sqr1) +) 0 '(1 2 3 4))
> 34
((mapping sqr1) cons)，就像cons本身一样，是两个参数的函数，因此可以用作foldl的 reducer function 参数。
(define g ((mapping sqr1) cons))与
(define (g x acc)
(cons (sqr1 x) acc))
我们有filtering
> (foldl ((filtering even?) +) 0 '(1 2 3 4))
> 6
> (foldl ((mapping sqr1) ((filtering even?) cons)) '() '(1 2 3 4))
> '(10 2)
> (foldl ((filtering even?) ((mapping sqr1) cons)) 0 '(1 2 3 4))
> '(17 5 . 0)
因此，((mapping sqr1) ((filtering even?) cons))是一个reducer，其中(mapping sqr1)使用((filtering even?) cons)作为的 reducer。并且 (filtering even?)使用cons作为其 - final in the chain - reducer function：
(define g
((mapping sqr1) ((filtering even?) cons)))
=
(define (g x acc)
(let ((f ((filtering even?) cons)))
(f (sqr1 x) acc))) ; by definition of mapping
=
(define (g x acc)
(define (f y acc)
(if (even? y) (cons y acc) acc)) ; by definition of filtering
(f (sqr1 x) acc))
=
(define (g x acc)
(let ((y (sqr1 x)))
(if (even? y) (cons y acc) acc))) ; by application rule
嗯，映射，过滤和提取都是自动汇总到一个减速器功能中，就好像我们自己写的一样！更好的是，foldl是尾递归的，整个函数是迭代的，只执行一次列表遍历 - 因为三个reducer函数合并为一个。
更多测试：
(define (bar xs)
(foldl ((compose
(filtering even?) ; filtering is done first
(mapping sqr1))
cons)
0 xs))
(define (baz xs)
(foldl ((compose
(mapping sqr1) ; mapping is done first
(filtering even?))
cons)
'() xs))
这样
> (bar '(1 2 3 4 5))
'(17 5 . 0)
> (baz '(1 2 3 4 5))
'(26 10 2)
答案 1 :(得分：1)
(define (sum ls)
(if (null? ls)
0
(if (even? (car ls))
(+ (square (car ls)) (sum (cdr ls)))
(sum (cdr ls)))))
，其中
(define (square x)
(* x x))
求和偶数元素的平方。如果你在不做任何事情的情况下对列表中的元素求和，当然答案不能解决你的问题。
更重要的是，可以用这种方式实现这个过程：
(define (sum ls)
(reduce +
0
(map square
(filter even?
ls))))
其中map，filter和reduce是常见含义（您可以在mit-scheme中尝试）。这也是做同样的事情，但这更具可读性，并且优化了cdr递归之类的功能。 SICP的第二章（结构与解释
计算机程序）介绍了这种编程方法。
答案 2 :(得分：1)
有两种可能性，我们要么从头开始实现递归：
(define (sum elemList)
(cond ((null? elemList) 0)
((even? (car elemList))
(+ (* (car elemList) (car elemList))
(sum (cdr elemList))))
(else (sum (cdr elemList)))))
或者我们使用内置程序，根据需要定义帮助程序。此策略称为使用"sequences as conventional interfaces"：
(define (square x)
(* x x))
(define (sum elemList)
(apply +
(map square
(filter even? elemList))))
在Scheme中，首选方式是第二种方式，因为当我们拥有已经为我们完成工作的程序时，我们不能重新发明轮子。无论哪种方式，它都按预期工作：
(sum '(1 2 3 4 5 6 7 8 9 10))
=> 220
答案 3 :(得分：1)
或使用SICP样式流！
如果您对此感兴趣，请参阅计算机程序的结构和解释（Sussman，Abelson）
此处的流函数的工作方式与@ WillNess的答案中描述的传感器非常相似 - 即，流不需要通过数据进行多次迭代
这里的所有流过程都是递归的，但是演变为线性迭代过程
值得注意的是，cons-stream是一种特殊形式，不能立即评估它的第二个参数
#lang sicp
(define (square x)
(* x x))
(define stream-car car)
(define (stream-cdr s)
(force (cdr s)))
(define (integers x)
(cons-stream x (integers (inc x))))
(define (stream-filter f s)
(cond ((stream-null? s) the-empty-stream)
((f (stream-car s)) (cons-stream (stream-car s) (stream-filter f (stream-cdr s))))
(else (stream-filter f (stream-cdr s)))))
(define (stream-map f s)
(if (stream-null? s)
the-empty-stream
(cons-stream (f (stream-car s)) (stream-map f (stream-cdr s)))))
(define (stream-take n s)
(cond ((stream-null? s) the-empty-stream)
((> n 0) (cons-stream (stream-car s) (stream-take (dec n) (stream-cdr s))))
(else the-empty-stream)))
(define (stream-reduce f acc s)
(if (stream-null? s)
acc
(stream-reduce f (f acc (stream-car s)) (stream-cdr s))))
(stream-reduce + 0
(stream-map square
(stream-filter even?
(stream-take 10
(integers 1)))))
;; => 220
<强>换能器
我怀着极大的感情向@WillNess提出这部分答案
我是introduced to transducers通过一个擅长将绝大多数复杂的东西提炼到奇迹般简单的人 - 作为一种爱的劳动，我已经适应了一些代码/想法（最初在javascript）计划
每个;; [section]定义一个抽象障碍
修改：删除了cons-cont和cons-trans的特殊表单 - 宏没有严格提高代码可读性
#lang sicp
;; [procedure]
(define (compose f g)
(lambda (x) (f (g x))))
;; [list]
(define (foldl f acc xs)
(if (null? xs)
acc
(foldl f (f acc (car xs)) (cdr xs))))
;; [continuation]
(define cons-cont
identity)
(define the-empty-cont
identity)
(define cont-concat
compose)
(define (cont-concat-all cs)
(foldl cont-concat the-empty-cont cs))
;; [trans]
(define (cons-trans f)
(cons-cont (lambda (cont) (lambda (acc x) (f cont acc x)))))
(define the-empty-trans
the-empty-cont) ;; unused in this program, but completes implementation
(define trans-concat
cont-concat) ;; unused in this program, but completes implementation
(define trans-concat-all
cont-concat-all)
;; [transducer]
(define (cons-transducer . ts)
(lambda (f acc xs)
(foldl ((trans-concat-all ts) f) acc xs)))
(define (mapper f)
(cons-trans (lambda (next acc x) (next acc (f x)))))
(define (filterer f)
(cons-trans (lambda (next acc x) (if (f x) (next acc x) acc))))
(define (effector f)
(cons-trans (lambda (next acc x) (f x) (next acc x))))
(define (logger s)
(effector (lambda (x) (display s) (display " ") (display x) (display "\n"))))
;; [main]
(define (square x)
(* x x))
(define (main xs)
((cons-transducer (logger "input")
(filterer even?)
(logger "filtered")
(mapper square)
(logger "squared"))
+ 0 xs))
(main '(1 2 3 4 5 6 7 8 9 10))
输出
input 1
input 2
filtered 2
squared 4
input 3
input 4
filtered 4
squared 16
input 5
input 6
filtered 6
squared 36
input 7
input 8
filtered 8
squared 64
input 9
input 10
filtered 10
squared 100
=> 220