#lang racket

;;; Задача 1

(define (ordered? xs pred)
  (cond [(< (length xs) 2) #t]
        [(not (pred (car xs) (car (cdr xs)))) #f]
        [else (ordered? (cdr xs) pred)]))

(ordered? '(1 2 3 4 5) <) ; -> #t
(ordered? '(1 2 3 6 5) <) ; -> #f

;;; Задача 2

(define (max-ordered-sublist xs)
  (define (calc xs biggest-sl current-sl)
    (cond [(null? xs) (reverse biggest-sl)]
          [(> (length current-sl) (length biggest-sl)) (calc xs current-sl current-sl)]
          [(< (car xs) (car current-sl)) (calc (cdr xs) biggest-sl (list* (car xs) current-sl))]
          [else (calc (cdr xs) biggest-sl (list (car xs)))]))
  (calc (cdr xs) (list (car xs)) (list (car xs))))

(max-ordered-sublist '(1 2 3 4 5 1 0)) ; -> '(5 1)

;;; Задача 3

(define (flatten xs)
  (cond [(not (list? xs)) (list xs)]
        [(null? (cdr xs)) (flatten (car xs))]
        [else (append (flatten (car xs)) (flatten (cdr xs)))]))

(flatten '((1 2 3) (4 5 6) ((7 8) (9 10 (11 (12)))))) ; -> '(1 2 3 4 5 6 7 8 9 10 11 12)

;;; Задача 4

(define (assoc key a-list)
  (cond [(null? a-list) '()]
        [(equal? key (caar a-list)) (cdar a-list)]
        [else (assoc key (cdr a-list))]))

(assoc 'b '((a 10) (c 6) (b 11) (b 45) (djf 9)))

;;; Задача 5

(define (replace lst dict)
  (cond [(null? lst) lst]
        [else (append (assoc (car lst) dict) (replace (cdr lst) dict))]))

(replace '(1 2 3 4) '((1 a) (2 b) (3 c) (4 d))) ; -> '(a b c d)

;;; Задача 6

(define (deep-delete lst)
  (define (calc lst depth)
    (cond [(null? lst) lst]
          [(list? (car lst)) (list (calc (car lst) (add1 depth)) (calc (cdr lst) depth))]
          [(< (car lst) depth) (calc (cdr lst) depth)]
          [else (list* (car lst) (calc (cdr lst) depth))]))
  (calc lst 1))

(deep-delete '(1 (2 (2 4) 1) 0 (3 (1)))) ; -> (1 (2 (4)) (3 ())))

;;; Задача 7

(define (diagonal mat)
  (define (calc mat ind result)
    (cond [(null? mat) result]
          [else (calc (cdr mat) (add1 ind) (append result (list (list-ref (car mat) ind))))]))
  (calc mat 0 '()))

(define matrix '((1 2 3 4)
                 (5 6 7 8)
                 (9 10 11 12)
                 (13 14 15 16)))
(diagonal matrix) ; -> (1 6 11 16)

;;; Задача 8

(define (tabulate f)
  (lambda (a b)
    (define (calc a result)
      (if (> a b)
        result
        (calc (add1 a) (append result (list (cons a (f a)))))))
    (calc a '())))

((tabulate sqr) 1 5) ; -> '((1 . 1) (2 . 4) (3 . 9) (4 . 16) (5 . 25))