ULOHY
-------

Ulohy od tejto sady silne odporucam skusat si s pouzitim interpretu, kedze
zacina byt nutny pre overenie funkcnosti rieseni.

1. Urcte, ktore z nasledujucich vyrazov/definicii nie su korektne.
a) f []    = 0
   f x:x:s = f (x:s)
   f x:y:s = x : f (y:s)
b) x `test` y = x + y * 10 - mod (x + 1) 3
c) map even [11,12,23,4.0]
d) map even . map length
e) makro s = makro t
     where (h:t) = decompose s
f) filter (+3) [[1,2],[4,5,6]]
g) map not (map not (map not (map even [])))
h) truecount s = length (filter True s)
i) maketrue s = map True s
j) f -1 = 4
   f 2  = -2
   f n  = 2 * f (n - 1) + f (n - 2) - 1

2. Urcte, ktory riadok sa pouzije na vyhodnotenie daneho vyrazu. Netreba
   uvazovat, ktore vsetky riadky (v pripade rekurzivnej funkcie), vzdy staci
   ten prvy. Tiez nie je podstatne, co robia funkcie (su uplne nahodne
   vymyslene :)).

a) f 3    = 11
   f n    = n - 3 * pi
   f (-2) = 0

   f (-2), f 5

b) f []      = 2
   f (x:_:s) = 10 * x + f (1:s)
   f [_,1,m] = m

   f [2], f [pi, pi, pi], f [1..]

3. Vyhodnotte 
a) zipWith (+) (map length [[], [[]], [[], [[]]]]) (filter even [-1,4,1,6,3,2,div 11 0])
b) f [] = []
   f (x:s) = x:x:' ':f s
   vyhodnotit f "ahoj"

4. Napiste vyrazy/funkcie podla daneho popisu
a) vyraz, ktory sa vyhodnoti na [(0,0),(1,1),(2,4),(3,9),...] (moze sa
   hodit zapis [a..b] alebo jeho varianty)
b) funkcia typu a -> [a] -> Int, ktora vrati pocet vyskytov prvku v zozname
   i) s explicitnym pouzitim rekurzie bez funkcii map, filter, atd.
   ii) lubovolnym sposobom
c) funkcia, ktora vrati zoznam sufixov daneho zoznamu (treba pouzit rekurziu
   a dobre premysliet, co bude vracat:
   napr. f [1,2,3] ~> [[1,2,3], [2,3], [3], []]



 RIESENIA
----------

1.
a) nok, vzor v 2. a 3. riadku, ktory pouziva infixove operatory,
   predovsetkym :, musi byt v zatvorkach, teda napr. f (x:x:s)
b) ok, funkcia moze byt definovana aj infixovo
c) nok, posledny prvok zoznamu je necele cislo (pretoze obsahuje desatinnu
   bodku; na to, ze je to vlastne 4 sa vobec nepozera)
d) ok, zoberie zoznam, na ktoreho prvky aplikuje length a nasledne even;
   t.j. kazdy prvok musi byt zoznam a nakoniec vrati True/False podla toho,
   ci jeho dlzka bola parna
e) ok, where konstrukcia je korektna, podobne ako v definicii unzip;
   ocakava, ze decompose vrati zoznam s aspon jednym prvkom (ak nie,
   doslo by k chybe)
f) nok, hned dve chyby, prva - lepsie by bolo map (+3) [[1,2],[4,5,6]],
   avsak to nerobi map [[4,5],[7,8,9]], na to by bolo treba inu funkciu
   (aku?)
g) ok, hlupe opakovanie map not, ale co uz
h) nok, filter musi ako prvy argument brat funkciu typu a -> Bool, avsak
   True ma typ Bool; zamyslany zamer mohol byt: filter (==True) s
i) nok, podobne, map musi ako prvy argument brat funkciu typu a -> b,
   ale True :: Bool; ak islo o nahradenie vsetkych hodnot hodnotou True,
   spravne by bolo  maketrue s = map f s where f _ = True (da sa aj
   elegantnejsie, ale nie so sucasnymi znalostami)
j) nok, pokial je vzorom funkcie zaporne cislo, musi byt uvedene v zatvorkach,
   teda f (-1) = 4

2.
a) f (-2): druhy, interpret sa pokusi pouzit definicie v poradi, v akom idu
   a na (-2) je mozne pouzit n
   f 5: druhy, zrejme
b) f [2]: ziadny, prvy riadok pre prazdne zoznamy, druhy pre zoznamy s aspon
   dvomi prvkami a treti pre zoznamy s tromi prvkami
   f [pi, pi, pi]: druhy, sice treti je specifickejsi a viac zodpoveda, ale
   je az po druhom a ide sa nekompromisne po poradi
   f [1..]: druhy, ma aspon dva prvky (a samozrejme nie je prazdny)

Pokial by ste si skutocne napisali taketo definicie a pokusili sa ich
nacitat v interprete, on vas na prekryvanie upozorni (napr f (-2) po f n).

3.
a) ~> length [] + 4 : zipWith (+) (map length [[[]], [[], [[]]]]) (filter even [1,6,3,2,div 11 0])
   ~> 4 : length [[]] + 6 : zipWith (+) (map length [[[], [[]]]]) (filter even [3,2,div 11 0])
   ~> 4 : 7 : length [[], [[]]] + 2 : zipWith (+) (map length []) (filter even [div 11 0])
   ~> 4 : 7 : 4 : zipWith (+) [] (filter even [div 11 0])
   ~> 4 : 7 : 4 : [] = [4,7,4]
   hodnota div 11 0 nikdy nie je potrebna, preto sa ani nevypocita (normalna redukcna strategia)
b) ~> 'a':'a':' ':f "hoj" ~> ... ~> "aa hh oo jj "

4.
a) zip [0..] (map (^2) [0..])
b) f1 x s = length (filter (x==) s)
   alebo
   f1 x = length . filter (x==)

   f2 _ []    = 0
   f2 n (x:s) = (if n == x then 1 else 0) + f2 n s
c) f []    = [[]]
   f (x:s) = (x:s) : f s
   pripadne trochu menej elegantne (null :: [a] -> Bool vracia True
   pre prazdny zoznam)
   f s = if null s then [[]] else s : f (tail s)