#lang racket
;Task 7 from week 2
(define (divisors-sum n)
  (define (loop i sum)
    (if (< i n)
    (if (zero? (remainder n i))
        (loop (+ i 1) (+ sum i))
        (loop (+ i 1) sum)

        )
    sum))
    (loop 1 0))

;Task 8 from week 2
(define (perfect? n)
  (= n (divisors-sum n)))

;Task 9 from week 2
(define (prime? n)
  (define (loop i)
    (cond [(> i (sqrt n)) #t]
          [(zero? (remainder n i)) #f]
          [else (loop (+ i 1))]))
  (if (= n 1)
      #f
      (loop 2)))

;Task 10 from week 2

(define (last n)
  (remainder n 10))

(define (quot n)
  (quotient n 10))

(define (increasing? n)
  (define (loop n)
    (cond [(< n 10) #t]
          [(> (last n) (last (quot n))) (loop (quot n))]
          [else #f]))
  (loop n))


;Task 11 from week 2

(define (to-binary n)
  (if (< n 2)
      n
      (+ (* 10 (to-binary (quotient n 2)))
         (remainder n 2))))

;Iterative

(define (to-binary* n)
  (define (loop n res bits)
    (if (= n 0)
        res
        (loop (quotient n 2)
              (+ res (* (remainder n 2) (expt 10 bits)))
              (+ bits 1))))
  (loop n 0 0))


;Accumulate definition
;It's standart, but should be well known to us.
(define (accumulate op nv a b term next)
  (if (> a b)
      nv
      (op (term a)
          (accumulate op nv (next a) b term next))))

;Task 1 from week 3
(define (!! n)
  (accumulate
   * 1
   (if (even? n) 2 1) n
   (lambda (x) x)
   (lambda (x) (+ x 2))))