#lang racket
; Стандартни функции...
(define (id x) x)
(define (++ x) (+ x 1))

(define (accumulate op null-value term a next b)
  (if (> a b)
      null-value
      (op (term a) (accumulate op null-value term (next a) next b))))

(define (filter-accum pred? op null-value term a next b)
  (cond [(> a b) null-value]
        [(pred? a) (op (term a)
                       (filter-accum pred? op null-value term (next a) next b))]
        [else          (filter-accum pred? op null-value term (next a) next b)]))

;# Вариант 1:
(define (min-sum-digit a b k)
  (define (divides? n k) (zero? (remainder n k)))
  (filter-accum (lambda (i) (divides? i k))
                     min
                     +inf.0
                     id
                     a
                     ++
                     b))

(define (calcprod f n)
  (define (average f g)
    (lambda (x) (/ (+ (f x) (g x)) 2)))
  (accumulate *
              1
              (lambda (i) ((average f (lambda (x) (expt i x))) i))
              1
              ++
              n))

(define (occurrences lst1 lst2)
  (define (count el lst) (length (filter (lambda (x) (equal? el x)) lst)))
  (define (length-1 lst) (apply + (map (lambda (x) 1) lst)))
  (map (lambda (el) (count el lst2)) lst1))

(define (match-lengths lst1 lst2)
  (define (are-all-same lst)
    (null? (filter (lambda (el) (not (equal? el (car lst)))) lst)))
  (let* [(lengths1 (map length lst1))
         (lengths2 (map length lst2))
         (len-diffs (map (lambda (x y) (abs (- x y))) lengths1 lengths2))]
    (are-all-same len-diffs)))

;# Вариант 2:
(define (prod-sum-div a b k)
  (define (divides? n k) (zero? (remainder n k)))
  (filter-accum (lambda (i) (divides? i k))
                     *
                     1
                     id
                     a
                     ++
                     b))

(define (calcsum f n)
  (define (average f g)
    (lambda (x) (sqrt (* (f x) (g x)))))
  (accumulate +
              0
              (lambda (i) ((average f (lambda (x) (expt x i))) i))
              1
              ++
              n))

(define (duplicates lst1 lst2)
  (define (count el lst) (length (filter (lambda (x) (equal? el x)) lst)))
  (filter (lambda (el) (> (count el lst2) 1)) lst2))

(define (image lst1 lst2)
  (define (are-all-same lst)
    (null? (filter (lambda (el) (not (equal? el (car lst)))) lst)))
  (are-all-same (map - lst1 lst2)))