#lang scheme

(define (task1 matrix)
  (define (countZero lst)
    (foldl (lambda (x res)
             (if (zero? x)
                 (+ res 1)
                 res))
           0 lst))

  (car (foldl (lambda (row res)
                (if (>(countZero row) (cdr res))
                    (cons row (countZero row))
                    res))
              (cons '() 0) matrix)))

(define (task2 n)
  (define (cddr lst)
    (if (null? lst)
        '()
        (cdr lst)
        ))
  (define (builder k)
    (append (build-list k (λ(x) 1)) (build-list (- (ceiling (/ n 2)) k) (λ(x) 0))))

  (define iter (build-list (ceiling (/ n 2)) (λ(x) (+ x 1))))
  (define raw_res (foldr (lambda (i res)
                           (if (even? n)
                               (cons (append (builder i) (reverse (builder i))) res)
                               (cons (append (builder i) (cdr (reverse (builder i)))) res)))
                         '() iter))
  (if (even? n)
      (append raw_res (reverse raw_res))
      (append raw_res (cdr (reverse raw_res))))
  )

(define (task3 matrix)
  (define (maxInCol matrix)
    (apply map max matrix))
  (define (maxInRow row)
    (apply min row))
  (define (getSaddlePoints row maxColElems)
    (define minRowElems (maxInRow row))
    (foldl (lambda [elem maxColElems result]
             (if (= elem maxColElems minRowElems)
                 (cons elem result)
                 result)) '() row maxColElems))

    (define maxColElems (maxInCol matrix))
    (define result (flatten (map (lambda [row]
                                   (getSaddlePoints row maxColElems)) matrix)))
    (if (empty? result)
        #f
        result)
  )




(define (task4 matrix)
  (define len (length (car matrix)))
  (define mainDiag (foldl (lambda (row n diag)
                            (cons (list-ref row n) diag)) null matrix
                                                          (build-list len values)))
  (define secondDiag (foldl (lambda (row n diag)
                              (cons (list-ref (reverse row) n) diag)) null (reverse matrix)
                                                                      (build-list len values)))

  (define matrT (apply map list matrix))
  (define sum (apply + (car matrix)))
  (if (foldl (lambda (row res)
               (cond ((eq? res #f) #f)
                     ((= (apply + row) sum) #t)
                     (else #f))) #t matrix)
      (if (foldl (lambda (col res)
                   (cond ((eq? res #f) #f)
                         ((= (apply + col) sum) #t)
                         (else #f))) #t matrT)
          (if (= (apply + mainDiag) sum)
              (if (= (apply + secondDiag) sum)
                  #t
                  #f)
              #f)
          #f
          )
      #f
      )
  )


(define (task5 matrix)
  (define (trans matrix)
    (apply map list matrix))

  (define matrT (trans matrix))
  (foldl (lambda [row result]
           (if result
               result
               (if (ormap (lambda [col]
                            (equal? row col)) matrT)
                   row
                   #f))) #f matrix))