(define (accumulate start end null-value pred? term comb)
  (if (> start end)
      null-value
      (comb
       (if (pred? start)
           (term start)
           null-value)
       (accumulate (+ start 1) end null-value pred? term comb)
      )
  )
)
;(accumulate 1 100 0 (lambda (x) #t) (lambda (x) x) +)

(define (concat start end)
  (define (num-digits n sum)
  (if (< n 10)
      (+ sum 1)
      (num-digits (/ n 10) (+ sum 1))))
  (define (concat-two k1 k2)
    (if (= k2 0)
        k1
        (+ (* k1 (expt 10 (num-digits k2 0))) k2)))
  (accumulate start end 0 (lambda (x) #t) (lambda (x) x) concat-two))
;(concat 1 9)
;(concat 19 23)


(define (mix l1 l2)
  (define (construct-mix-list l1 l2)
  (if (or (null? l1) (null? l2))
      ()
      (cons (car l1) (construct-mix-list (cdr l2) (cdr l1)))))
  (cons (construct-mix-list l1 l2) (construct-mix-list l2 l1)))
;(mix '(1 2 3 4 6 7) '(9 9 9 9 9 9))
;(mix '(9 9 9 9 9 9) '(1 2 3 4 6 7))
;(mix '(1 2 3 4 6 7) '(9 9 9 9 9))
;(mix '(9 9 9 9 9) '(1 2 3 4 6 7))

(define (repeat-k f k)
  (if (= k 0)
      (lambda (x) x)
      (lambda (x) (f ((repeat-k f (- k 1)) x)))))

(define (task f)
  (define (find-depth f a b k)
    (define rep (repeat-k f k))
    (if (> (rep a) b)
        rep
        (find-depth f a b (+ k 1))))
  (lambda (a b)
    (find-depth f a b 1)))
;(((task (lambda (x) (+ x 1))) 1 10) 2)
;(((task (lambda (x) (+ x 1))) 8 10) 2)

(define (switchsum f g n)
  (define (nest f g n)
    (cond
      ((= n 0) (lambda (x) x))
      ((= (remainder n 2) 0) (lambda (x) (g ((nest f g (- n 1)) x))))
      (else (lambda (x) (f ((nest f g (- n 1)) x))))))
  (if (= n 0)
      (lambda (x) 0)
      (lambda (x) (+ ((nest f g n) x) ((switchsum f g (- n 1)) x)))))
;((switchsum (lambda (x) (+ x 1)) (lambda (x) (* x 2)) 3) 5)

(define (ksum k a b)
  (define (k-member n k digit sum)
    (cond
      ((< n 1) sum)
      ((= (remainder digit k) 0) (k-member (quotient n 10) k (+ digit 1) (+ (* sum 10) (remainder n 10))))
      (else (k-member (quotient n 10) k (+ digit 1) sum))))
  (accumulate a b 0 (lambda (x) #t) (lambda (x) (k-member x k 0 0)) +))
;(ksum 1 1 200)

(define (replace l change)
  (define (find-di ci cur-chg)
    (cond
      ((null? cur-chg) ci)
      ((= ci (caar cur-chg)) (cdar cur-chg))
      (else (find-di ci (cdr cur-chg)))))
  (if (or (null? l) (null? change))
      ()
      (cons (find-di (car l) change) (replace (cdr l) (cdr change)))))
;(replace '(1 2 7 9 3) (list (cons 1 11) (cons 2 22) (cons 8 3) (cons 9 99) (cons 3 7)))