62 lines
1.7 KiB
Racket
62 lines
1.7 KiB
Racket
#lang racket
|
|
|
|
(define (accumulate op initial sequence)
|
|
(if (null? sequence)
|
|
initial
|
|
(op (car sequence)
|
|
(accumulate op initial (cdr sequence)))))
|
|
|
|
(define (square x) (* x x))
|
|
|
|
;; 2.30 oooh, we getting cool now are we?
|
|
(define (square-tree l)
|
|
(cond
|
|
((null? l) l)
|
|
((list? (car l)) (cons (square-tree (car l))
|
|
(square-tree (cdr l))))
|
|
(#t (cons (square (car l))
|
|
(square-tree (cdr l))))))
|
|
|
|
(define (square-tree-map l)
|
|
(map (λ (x)
|
|
(if (list? x)
|
|
(square-tree-map x)
|
|
(square x)))
|
|
l))
|
|
|
|
;; 2.31 hohoohoho nice
|
|
(define (tree-map f l)
|
|
(map (λ (x)
|
|
(if (list? x)
|
|
(tree-map f x)
|
|
(f x)))
|
|
l))
|
|
(define (square-tree-final l) (tree-map square l))
|
|
|
|
;; 2.32 hmm.. cool stuff.
|
|
(define (subsets s)
|
|
(if (null? s)
|
|
(list '())
|
|
(let ((rest (subsets (cdr s))))
|
|
(append rest (map (λ (l) (cons (car s) l)) rest)))))
|
|
;; The reason this works, is because the set of subsets of a set s
|
|
;; can be defined as such:
|
|
;; - if s is the empty set, the result is a set containing the empty set
|
|
;; - otherwise, the result is a set containing:
|
|
;; 1. the subsets of s without the first element of s
|
|
;; 2. the subsets of s with the first element of s
|
|
;; 2 can be defined as the first element of s added to every
|
|
;; subset of s that does not contain the first element of s.
|
|
;; probably not a very rigorous or formal definition, but good
|
|
;; enough for now.
|
|
|
|
|
|
;; 2.33
|
|
(define (map p sequence)
|
|
(accumulate (lambda (x y) ⟨??⟩) nil sequence))
|
|
(define (append seq1 seq2)
|
|
(accumulate cons ⟨??⟩ ⟨??⟩))
|
|
(define (length sequence)
|
|
(accumulate ⟨??⟩ 0 sequence))
|
|
|