#lang scheme/base

(define (funI lst)
  (cond ((null? lst) '()))
  ; хэлпер - текущее-значение текущий-индекс текущий-максимум остаток-списка список-индексов-максимальных-элементов
  (define (helper value index cur-max rest max-indexes)
    (cond ((null? value) (reverse max-indexes))
          ((null? rest) (
                         cond ((> value cur-max) (list index))
                              ((= value cur-max) (reverse (cons index max-indexes)))
                              (else (reverse max-indexes))))
          ((> value cur-max) (helper (car rest) (+ 1 index) value (cdr rest) (list index)))
          ((= value cur-max) (helper (car rest) (+ 1 index) cur-max (cdr rest) (cons index max-indexes)))
          (else (helper (car rest) (+ 1 index) cur-max (cdr rest) max-indexes))))
  (helper (car lst) 0 -inf.0 (cdr lst) '())

)

(define (funIIa n)
  ;проверка на простоту
  (define (simple x)
    (cond ((or (= x 0) (= x 1) (= x 2) (= x 3)) #t)
          (else
    (andmap (lambda (y) (not (zero? (remainder x y)))) (build-list (- x 2) (lambda (x) (+ 2 x)))))))
  ;проверка на то, является ли х делителем у
  (define (divider x y) (zero? (remainder y x)))
  (define (helper original-n n)
    (cond ((= n 1) '())
          ((and (simple n) (divider n original-n)) (cons n (helper original-n (- n 1))))
          (else (helper original-n (- n 1))) ))

  (helper n n))

; (funIIa 2)

(define (funIIb n)
  ;проверка на простоту
  (define (simple x)
    (andmap (lambda (y) (not (zero? (remainder x y)))) (build-list (- x 2) (lambda (x) (+ 2 x)))))
  ;проверка на то, является ли х делителем у
  (define (divider x y) (zero? (remainder y x)))
  (cond ((= n 1) '())
        ((= n 2) (list 2)))
  (reverse (filter (lambda (x) (and (simple x) (divider x n))) (build-list (- n 1) (lambda (x) (+ 2 x))))))

; (funIIb 12)

(define (funIII k)
  (define (fib-n n)
    (define (helper result a1 a2 n)
      (if (> (+ a1 a2) n) result (helper (cons (+ a1 a2) result) a2 (+ a1 a2) n)))
    (cond ((= n 1) (list 1))
          ((= n 2) (list 2 1))
          (else (helper (list 2 1) 1 2 n))))

  (define (num-to-fib-bits result number fib-list)
    (cond ((and (= number 0) (null? fib-list)) result)
          ((>= number (car fib-list)) (num-to-fib-bits (cons 1 result) (- number (car fib-list)) (cdr fib-list)))
          (else (num-to-fib-bits (cons 0 result) number (cdr fib-list)))))

  (define (bits-to-num result bits power)
    (cond ((null? bits) result)
          ((= 1 (car bits)) (bits-to-num (+ result power) (cdr bits) (* power 2)))
          (else (bits-to-num result (cdr bits) (* power 2)))))

  (bits-to-num 0 (num-to-fib-bits '() k (fib-n k)) 1)
  )

; (funIII 9)

(define (funIV tree h1 h2)
  ;удовлетворяет ли элемент условиям
  ;значение высота-1 высота-2 текущая-высота
  (define (pred val h1 h2 cur-h) (if (and (< val 0) (or (and (<= cur-h h1) (>= cur-h h2)) (and (>= cur-h h1) (<= cur-h h2)))) 1 0))
  (define (helper tree h1 h2 cur-h)
    (cond ((= (vector-length tree) 0) 0)
          (else (+ (pred (vector-ref tree 0) h1 h2 cur-h) (foldl + 0 (map (lambda (x) (helper x h1 h2 (+ 1 cur-h))) (cdr (vector->list tree))))))))
  (helper tree h1 h2 0)
)

;(funI (list -1 0 1 -1 0 1 -1))
;(funIV #(1 #(2 #(-3 #()) #(3)) #(-2 #(4) #(0) #(-4))) 1 0)

(define (funV-cps tree h1 h2 cc)
  )