;ROTUJ-VLAVO :: [a] -> [a]
(DEFUN ROTUJ-VLAVO (ZOZ)
    (APPEND (REST ZOZ) (LIST (FIRST ZOZ))) )

      ;OHRANICENIE :: (int x int x int) -> int
(DEFUN OHRANICENIE (X MINIMUM MAXIMUM)
    (COND ((< X MINIMUM) MINIMUM)
          ((> X MAXIMUM) MAXIMUM)
          ( T X) ))
 
      ;SUSED :: int -> int
(DEFUN SUSED (N)
    (COND ((< N 0) (- N 1))
          ((> N 0) (+ N 1))
          ( T N) ))
 
      ;CYKLUS :: nat -> nat
(DEFUN CYKLUS (N)
    (COND ((= N 99) 1)
          ( T (+ N 1)) ))
 
      ;MIN-DVA :: (int x int) -> int
(DEFUN MIN-DVA (X Y)
    (COND ((< X Y) X)          ; X < Y?
          ( T Y) ))            ; X ? Y
 
      ;MAX-TRI :: (int x int x int) -> int
(DEFUN MAX-TRI (X Y Z)
    (COND ((AND (< X Y) 
                (OR (= Z Y)(< Z Y))) Y)
          ((AND (< X Z) (< Y Z)) Z)
          ( T X) ))
 
      ;OPERACIA :: (int x int x int) -> symb
(DEFUN OPERACIA (A1 A2 VYSLEDOK)
    (COND ((= (+ A1 A2) VYSLEDOK) 'PLUS)
          ((= (- A1 A2) VYSLEDOK) 'MINUS)
          ((= (* A1 A2) VYSLEDOK) 'KRAT)
          ((= (/ A1 A2) VYSLEDOK) 'DELENO)
          ( T NIL) ))
 
(DEFUN OPERACIA-HLAVNA ()
    (TERPRI)
    (PRINC " Zadaj prvy argument: ")
    (SETQ A1 (READ))
    (PRINC " Zadaj druhy argument: ")
    (SETQ A2 (READ))
    (PRINC " Zadaj vysledok: ")
    (SETQ VYSLEDOK (READ))
    (OPERACIA A1 A2 VYSLEDOK)  )

(DEFUN OPERACIA-HLAVNA1 ()
    (TERPRI)
    (OPERACIA (NACITAJ "Zadaj prvy argument : ")
              (NACITAJ "Zadaj druhy argument: ")
              (NACITAJ "Zadaj vysledok: ") ))
(DEFUN NACITAJ (TEXT)
    (PRINC TEXT)
    (READ) )
 
      ;MAX-TRI-HLAVNA :: (a x a x a) -> a
(DEFUN MAX-TRI-HLAVNA (X Y Z)
    (COND ((AND (NUMBERP X)(NUMBERP Y)(NUMBERP Z))
                  (MAX-TRI X Y Z))
          ( T 'CHYBA)  ))

      ;KVADER :: (int x int x int) -> (symb,real,real)
(DEFUN KVADER (A B C)
     (KVADER-AUX A B (- (* B B)(* 4 A C))))
(DEFUN KVADER-AUX (A B D)
     (LET ((MINUS-B (- B))
           (SQRT-D  (SQRT (ABS D)))
           (DVE-A   (* A 2)) )
       (COND ((< D 0)
                 (LIST 'KOMPLEX 
                       (/ MINUS-B DVE-A) 
                       (/ SQRT-D  DVE-A))  )
              (T (LIST 'REAL    
                       (/ (+ MINUS-B SQRT-D) DVE-A)
                       (/ (- MINUS-B SQRT-D) DVE-A)) ))  ))
 
      ;POCITAJ :: (a x a x b) -> int
(DEFUN POCITAJ (LAVY-OPERAND PRAVY-OPERAND OPERATOR)
      (EVAL (LIST OPERATOR LAVY-OPERAND PRAVY-OPERAND)) )

 
      ;SUCIN :: [int] -> int 
(DEFUN SUCIN (ZOZ)
  (COND ((NULL ZOZ) 1)
        ( T  (* (FIRST ZOZ) (SUCIN (REST ZOZ))))    ))
 
      ;MAP-CUBE :: [int] -> [int]
(DEFUN MAP-CUBE (ZOZ)
  (COND ((NULL ZOZ) NIL)
        ( T  (CONS (CUBE (FIRST ZOZ))
                   (MAP-CUBE (REST ZOZ))))  ))
(DEFUN CUBE (N) (* (* N N) N))
 
      ;VYBER-PARNE :: [a] -> [int]
(DEFUN VYBER-PARNE (ZOZ)
  (COND ((NULL ZOZ) NIL)
        ((AND (NUMBERP (FIRST ZOZ))
              (EVENP (FIRST ZOZ)))
                       (CONS (FIRST ZOZ)
                             (VYBER-PARNE (REST ZOZ))))
        (T  (VYBER-PARNE (REST ZOZ)))   ))
 
       ;POCET-PARNYCH :: [a] -> nat
(DEFUN  POCET-PARNYCH (ZOZ)
  (COND ((NULL ZOZ) 0)
        ((AND (NUMBERP (FIRST ZOZ))
              (EVENP (FIRST ZOZ)))
                        (+ 1 (POCET-PARNYCH (REST ZOZ))))
        (T (POCET-PARNYCH (REST ZOZ)))  ))
 
       ;PRVE-PARNE :: [a] -> int
(DEFUN  PRVE-PARNE (ZOZ)
  (COND ((NULL ZOZ) NIL)
        ((AND (NUMBERP (FIRST ZOZ))
              (EVENP (FIRST ZOZ)))
                               (FIRST ZOZ))
        (T (PRVE-PARNE (REST ZOZ)))  ))
 
      ;LAST-MY :: [a] -> [a]
(DEFUN LAST-MY (ZOZ)
  (COND ((NULL (REST ZOZ)) ZOZ)
        ( T (LAST-MY (REST ZOZ))) ))
 
      ;POSTFIX :: (a x [a]) -> [a]
(DEFUN POSTFIX (SV ZOZ)
  (COND ((NULL ZOZ) (LIST SV))
        ( T (CONS (FIRST ZOZ)
                  (POSTFIX SV (REST ZOZ)))) ))
 
      ;CISLA :: [a] -> bool
(DEFUN CISLA (ZOZ)
  (COND ((NULL ZOZ) T)
        ((NUMBERP (FIRST ZOZ)) (CISLA (REST ZOZ)))
        ( T  NIL)  ))
 
      ;PARNE :: [a] -> bool
(DEFUN PARNE (ZOZ)
  (COND ((NULL ZOZ) T)           ; prazdny ZOZ ? parny pocet prvkov
        ((NULL (REST ZOZ)) NIL)  ; jednoprvkovy ZOZ ? neparny pocet
        (T (PARNE                ; rekurzia ..
             (REST (REST ZOZ)))) ; .. o dva prvky kratsi ZOZ
))
 
      ;VYRAZ :: [a] -> bool
(DEFUN VYRAZ (SV)
  (OR (NUMBERP SV)                ; cislo je aritmeticky vyraz
      (AND (LISTP SV)             ; zoznam:
           (VYRAZ (FIRST SV))     ; prvy prvok je aritmeticky vyraz
           (OPERATOR (SECOND SV)) ; druhy prvok je operator
           (VYRAZ (THIRD SV))     ; treti prvok je aritmeticky vyraz
           (NULL (CDDDR SV)))     ; SV neobsahuje stvrty prvok
))

      ;OPERATOR :: symb -> bool
(DEFUN OPERATOR (OP)
  (OR (EQ OP '+) (EQ OP '-) (EQ OP '*) (EQ OP '/))  )
 
      ;MAX-ZOZ :: [a] -> nat
(DEFUN MAX-ZOZ (ZOZ)
  (MAX-ZOZ-AUX ZOZ 0))
      ;MAX-ZOZ-AUX :: ([a] x nat) -> nat
(DEFUN MAX-ZOZ-AUX (ZOZ POCET)
  (COND ((NULL ZOZ) POCET)
        ((ATOM (FIRST ZOZ))
                       (MAX-ZOZ-AUX (REST ZOZ) POCET))
        ((< POCET (LENGTH (FIRST ZOZ)))
                       (MAX-ZOZ-AUX (REST ZOZ)
                                    (LENGTH (FIRST ZOZ))))
        ( T (MAX-ZOZ-AUX (REST ZOZ) POCET))    ))

 
      ;MIN :: [int] -> int
(DEFUN MIN (ZOZ)
  (COND ((NULL (REST ZOZ)) (FIRST ZOZ))   ; koniec rekurzie
        ((< (FIRST ZOZ) (SECOND ZOZ))     ; prvy mensi ako druhy?
                (MIN (CONS (FIRST ZOZ)    ; zarad prvy (mensi)
                           (CDDR ZOZ))) ) ; druhy vynechaj
        ( T                               ; druhy mensi ako prvy
              (MIN (REST ZOZ)))  ))       ; prvy vynechaj
 
      ;ZLUC :: ([int] x [int]) -> [int]
(DEFUN ZLUC (ZOZ1 ZOZ2)
  (COND ((NULL ZOZ1) ZOZ2)
        ((NULL ZOZ2) ZOZ1)
        ((= (FIRST ZOZ1) (FIRST ZOZ2))
                 (CONS (FIRST ZOZ1)
                       (ZLUC (REST ZOZ1) (REST ZOZ2))))
        ((< (FIRST ZOZ1) (FIRST ZOZ2))
                 (CONS (FIRST ZOZ1)
                       (ZLUC (REST ZOZ1) ZOZ2)))
        ( T      (CONS (FIRST ZOZ2)
                       (ZLUC ZOZ1 (REST ZOZ2))))   ))
 
      ;PRVYCH-K :: (nat x [a]) -> [a]
(DEFUN PRVYCH-K (K ZOZ)
  (COND ((NULL ZOZ) NIL)
        ((= K 0) NIL)
        ( T  (CONS (FIRST ZOZ)
                   (PRVYCH-K (- K 1) (REST ZOZ))))   ))
 
      ;BEZ-PRVYCH-K :: (nat x [a]) -> [a]
(DEFUN BEZ-PRVYCH-K (K ZOZ)
  (COND ((= K 0) ZOZ)
        ( T  (BEZ-PRVYCH-K (- K 1) (REST ZOZ)))    ))
 
      ;ZAMEN :: (a x a x [a]) -> [a]
(DEFUN ZAMEN (SV1 SV2 ZOZ)
  (COND ((NULL ZOZ) NIL)
        ((EQUAL SV1 (FIRST ZOZ))
                      (CONS SV2
                            (ZAMEN SV1 SV2 (REST ZOZ))))
        ( T  (CONS (FIRST ZOZ)
                   (ZAMEN SV1 SV2 (REST ZOZ))))    ))
 
      ;V-CISLA :: [a] -> bool
(DEFUN V-CISLA (SV)
  (COND ((NULL SV) T)
        ((NUMBERP SV) T)
        ((ATOM SV) NIL)
        ( T  (AND (V-CISLA (FIRST SV))
                  (V-CISLA (REST SV))))   ))
 
      ;V-POCET-PARNYCH :: [a] -> nat
(DEFUN V-POCET-PARNYCH (SV)
  (COND ((AND (NUMBERP SV) (EVENP SV)) 1)
        ((ATOM SV) 0)
        ( T (+ (V-POCET-PARNYCH (FIRST SV))
               (V-POCET-PARNYCH (REST SV))))   ))
 
      ;V-PRVE-PARNE :: [a] -> int
(DEFUN V-PRVE-PARNE (SV)
  (COND ((AND (NUMBERP SV) (EVENP SV)) SV)
        ((ATOM SV) NIL)
        (T (OR (V-PRVE-PARNE (FIRST SV))
               (V-PRVE-PARNE (REST SV))))   ))
 
      ;V-VYBER-PARNE :: [a] -> [{a}]
(DEFUN V-VYBER-PARNE (ZOZ)
  (COND ((NULL ZOZ)  NIL)
        ((AND (NUMBERP (FIRST ZOZ))
              (EVENP (FIRST ZOZ)))
                     (CONS (FIRST ZOZ)
                           (V-VYBER-PARNE (REST ZOZ))))
        ((ATOM (FIRST ZOZ))
                     (V-VYBER-PARNE (REST ZOZ)))
        (T   (CONS (V-VYBER-PARNE (FIRST ZOZ))
                   (V-VYBER-PARNE (REST ZOZ))))   ))
 
      ;V-ZAMEN :: (a x a x [{a}]) -> [{a}]
(DEFUN V-ZAMEN (SV1 SV2 ZOZ)
  (COND ((NULL ZOZ) NIL)
        ((EQUAL SV1 ZOZ) SV2)
        ((ATOM ZOZ) ZOZ)
        ( T (CONS (V-ZAMEN SV1 SV2 (FIRST ZOZ))
                  (V-ZAMEN SV1 SV2 (REST ZOZ))))  ))

      ;ZATVORKY :: [{a}] -> [a]
(DEFUN ZATVORKY (X)
  (COND ((NULL X) NIL)
        ((ATOM X) (LIST X))
        ( T  (APPEND (ZATVORKY (FIRST X))
                     (ZATVORKY (REST X))))   ))
 
      ;SUCIN2 :: [int] -> int
(DEFUN SUCIN2 (ZOZ)
  (SUCIN-AUX ZOZ 1))
      ;SUCIN-AUX :: ([int] x int) -> int
(DEFUN SUCIN-AUX (ZOZ SUCIN)
  (COND ((NULL ZOZ) SUCIN)
        ( T  (SUCIN-AUX (REST ZOZ)
                        (* SUCIN (FIRST ZOZ))))  ))

      ;MAP-CUBE2 :: [int] -> [int]
(DEFUN MAP-CUBE2 (ZOZ)
  (MAP-CUBE-AUX ZOZ NIL))
      ;MAP-CUBE-AUX :: ([int] x [int]) -> [int]
(DEFUN MAP-CUBE-AUX (ZOZ MAP-ZOZ)
  (COND ((NULL ZOZ) MAP-ZOZ)
        (T (MAP-CUBE-AUX (REST ZOZ)
                  (APPEND MAP-ZOZ
                          (LIST (CUBE (FIRST ZOZ))))  ))   ))
 
      ;POCET-PARNYCH2 :: [a] -> nat
(DEFUN POCET-PARNYCH2 (ZOZ)
  (POCET-PARNYCH-AUX ZOZ 0))
      ;POCET-PARNYCH-AUX :: ([a] x nat) -> nat
(DEFUN POCET-PARNYCH-AUX (ZOZ POCET)
  (COND ((NULL ZOZ) POCET)
        ((AND (NUMBERP (FIRST ZOZ))
              (EVENP (FIRST ZOZ)))
                        (POCET-PARNYCH-AUX (REST ZOZ)
                                           (+ 1 POCET)))
        ( T (POCET-PARNYCH-AUX (REST ZOZ) POCET))   ))

      ;V-POCET-PARNYCH2 :: [a] -> nat
(DEFUN V-POCET-PARNYCH2 (SV)
    (V-POCET-AUX SV NIL 0))
      ;V-POCET-AUX :: ([a] x [a] x nat) -> nat
(DEFUN V-POCET-AUX (SV RSV AUX)
   (COND ((AND (NULL SV)(NULL RSV))          ;presli sme cely zoznam
                                   AUX)
         ((NULL SV)                          ;koniec FIRST casti
            (V-POCET-AUX (FIRST RSV)         ;spracujeme zvysky.
                         (REST  RSV)         ;a zasobnik skratime
			        AUX        ))
         ((AND (NUMBERP SV)(EVENP SV))        ;parne cislo
		(V-POCET-AUX NIL
			       RSV
				 (+ 1 AUX)   )) ;pripocitame do AUX
         ((ATOM SV)                             ;ostatne atomy.
		(V-POCET-AUX NIL
			       RSV
				 AUX         )) ;.nezapocitame
         (T                                     ;SV je zoznam.
		(V-POCET-AUX (FIRST SV)         ;.pokracujeme s FIRST
	    	   (CONS (REST SV) RSV)         ;a REST odlozime
				       AUX   ))
))	  
 
      ;ZLUC2 :: ([int] x [int]) -> [int]
(DEFUN ZLUC2 (ZOZ1 ZOZ2)
  (ZLUC-AUX ZOZ1 ZOZ2 NIL))
      ;ZLUC-AUX :: ([int] x [int] x [int]) -> [int]
(DEFUN ZLUC-AUX (ZOZ1 ZOZ2 VYSLEDOK)
  (COND ((NULL ZOZ1) (APPEND VYSLEDOK ZOZ2))
        ((NULL ZOZ2) (APPEND VYSLEDOK ZOZ1))
        ((= (FIRST ZOZ1) (FIRST ZOZ2))
                (ZLUC-AUX (REST ZOZ1) (REST ZOZ2)
                          (APPEND VYSLEDOK
                                  (LIST (FIRST ZOZ1)) )))
        ((< (FIRST ZOZ1) (FIRST ZOZ2))
                (ZLUC-AUX (REST ZOZ1) ZOZ2
                          (APPEND VYSLEDOK
                                  (LIST (FIRST ZOZ1)) )))
        ( T (ZLUC-AUX ZOZ1 (REST ZOZ2)
                      (APPEND VYSLEDOK
                              (LIST (FIRST ZOZ2)) )))  ))
 
      ;ANO-NIE :: string -> bool
(DEFUN ANO-NIE (TEXT)
  (PROG (ODPOVED)
        (TERPRI)
    ZAC (PRINC TEXT) (PRINC "   A/N ?  ")
        (SETQ ODPOVED (READ))
        (COND ((EQ ODPOVED 'A) (RETURN T))
              ((EQ ODPOVED 'N) (RETURN NIL))
              ( T (GO ZAC)))  ))

      ;ANO-NIE2 :: string -> bool
(DEFUN ANO-NIE2 (TEXT)
     (PRINC TEXT) (PRINC "   A/N ?  ")
     (ODPOVED (READ) TEXT))
      ;ODPOVED :: (a x string) -> bool
(DEFUN ODPOVED (SV TEXT)
     (COND ((EQ SV 'A)  T)
           ((EQ SV 'N)  NIL)
           ( T (ANO-NIE2 TEXT))  ))
 
      ;EVERY :: ((a -> bool) x [a]) -> bool
(DEFUN EVERY (FN ZOZ)
  (COND ((NULL ZOZ) T)
        ((FUNCALL FN (FIRST ZOZ))
              (EVERY FN (REST ZOZ)))
        (T NIL)  ))
 
      ;NESTED-REMOVE-IF :: ((a -> bool) x [b]) -> [b] 
(DEFUN NESTED-REMOVE-IF (FN ZOZ)
  (COND ((NULL ZOZ) NIL)
        ((FUNCALL FN (FIRST ZOZ))
             (NESTED-REMOVE-IF FN (REST ZOZ)))
        ((ATOM (FIRST ZOZ))
             (CONS (FIRST ZOZ)
                   (NESTED-REMOVE-IF FN (REST ZOZ))))
        ( T  (CONS (NESTED-REMOVE-IF FN (FIRST ZOZ))
                   (NESTED-REMOVE-IF FN (REST ZOZ))))  ))

      ;NESTED-MAP-IF :: ((a -> b)x(c -> bool)x[{c}]) -> [{b}]
(DEFUN NESTED-MAP-IF (FN-MAP FN-IF SV)
  (COND ((FUNCALL FN-IF SV) (FUNCALL FN-MAP SV))
        ((ATOM SV) SV)
        (T (CONS (NESTED-MAP-IF FN-MAP FN-IF (FIRST SV))
                 (NESTED-MAP-IF FN-MAP FN-IF (REST  SV))
        ))
))
 
      ;OBSAHUJE :: ((a -> bool)x[{a}]) -> bool
(DEFUN OBSAHUJE (FN SV)
  (COND ((FUNCALL FN SV) T)
        ((ATOM SV) NIL)
        (T (OR (OBSAHUJE FN (FIRST SV))
               (OBSAHUJE FN (REST SV))))  ))
 
 
      ;VYBER-ZAPORNE :: [a] -> [int]
(DEFUN VYBER-ZAPORNE (ZOZ)
    (REMOVE-IF-NOT #'(LAMBDA (X) (< X 0)) ZOZ))

      ;V-POCET-PARNYCH3 :: [a] -> nat
(DEFUN V-POCET-PARNYCH3 (SV)
   (COND ((AND (NUMBERP SV) (EVENP SV)) 1)
         ((ATOM SV) 0)
         ( T (APPLY '+ (MAPCAR #'V-POCET-PARNYCH3 SV)))  ))