blob: f8d96d05bac64d16c3f6161b7dd4824247dec26d (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
|
#lang racket
(provide accumulate
accumulate-n
fold-right
fold-left
flatmap
enumerate-interval
enumerate-windows)
(define (append list1 list2)
(if (null? list1)
list2
(cons (car list1) (append (cdr list1) list2))))
(define (length items)
(define (length-iter a c)
(if (null? a)
c
(length-iter (cdr a) (+ 1 c))))
(length-iter items 0))
(define (list-ref items n)
(if (= n 0)
(car items)
(list-ref
(cdr items)
(- 1 n))))
(define (last-pair l)
(if (null? (cdr l))
l
(last-pair (cdr l))))
(define (accumulate op initial sequence)
(cond ((null? sequence) initial)
(else (op (car sequence)
(accumulate op initial (cdr sequence))))))
(define (accumulate-n op init seqs)
(if (null? (car seqs))
'()
(cons (accumulate op init (map car seqs))
(accumulate-n op init (map cdr seqs)))))
(define (fold-right op initial sequence)
(accumulate op initial sequence))
(define (fold-left op initial sequence)
(define (iter result rest)
(if (null? rest)
result
(iter (op result (car rest))
(cdr rest))))
(iter initial sequence))
(define (flatmap proc seq)
(accumulate append '() (map proc seq)))
(define (enumerate-interval j k)
(define (iter i interval)
(if (< i j)
interval
(iter (- i 1) (cons i interval))))
(iter k '()))
(define (unique-pairs n)
(flatmap
(lambda (i)
(map (lambda (j) (list j i))
(enumerate-interval 1 (- i 1))))
(enumerate-interval 1 n)))
(define (enumerate-windows seq n)
(define (setup-n-window)
(define (rec i things)
(if (> i n)
(list '() things)
(let ((setup (rec (+ i 1)
(cdr things))))
(cons (cons (car things) (car setup))
(cdr setup)))))
(rec 1 seq))
(define (shift-window w item)
(append (cdr w) (list item)))
(define (iter result window things)
(if (null? things)
(cons window result)
(iter (cons window result)
(shift-window window (car things))
(cdr things))))
(let ((setup (setup-n-window)))
(iter '() (car setup) (cadr setup))))
(enumerate-windows
(enumerate-interval 1 4)
2)
|
