Programming Languages 2020/21 fall

3. Haskelli kodutöö

Lahenda järgmised ülesanded Haskelli moodulisse Kt3.

Moodle'ist leiad ka lahendusfaili malli Kt3.hs.

1. ülesanne (0.3p)

Kirjuta listi ümberpööramise funktsioon reverse', kasutades foldl-i.

Näiteks:

reverse [] ==> []
reverse [1,2,3] ==> [3,2,1]

reverse' :: [a] -> [a]
reverse' = foldl (#) a
  where
    a = undefined
    x # y = undefined

2. ülesanne (0.3p)

Kirjuta foldr-ga funktsioon eemaldaNullid, mis eemaldab listist kõik nullid. Teised listi elemendid peavad jääma samasse järjekorda.

Näiteks:

eemaldaNullid []           ==> []
eemaldaNullid [1,0,1,0,2]  ==> [1,1,2]
eemaldaNullid [1,1,0,0,2]  ==> [1,1,2]
eemaldaNullid [0,0,0,6,0]  ==> [6]

eemaldaNullid :: [Int] -> [Int]
eemaldaNullid = foldr (#) a
  where
    a = undefined
    x # y = undefined

3. ülesanne (0.4p)

Kasutades foldr-i, kirjuta funktsioon any', mis võtab argumendiks predikaadi ja listi. Tagasta True ainult siis, kui leidub listi element, mis rahuldab predikaati. (Vihje: || on disjunktsiooni operaator)

Näiteks:

any' isUpper "Tere!" ==> True   -- kuna isUpper 'T' == True
any' isUpper "terE!" ==> True   -- kuna isUpper 'E' == True
any' isUpper "tere!" ==> False

any' :: (a -> Bool) -> [a] -> Bool
any' p xs = undefined

isUpper funktsiooni kasutamiseks lisa faili päisesse import Data.Char.

4. ülesanne (0.4p)

Kasutades mõnda kõrgemat järku funktsiooni (nt foldr), kirjuta funktsioon allEqual, mis kontrollib, kas täisarvude listi kõik elemendid on võrdsed.

Näiteks:

allEqual []      ==> True
allEqual [1,2]   ==> False
allEqual [1,1,1] ==> True
allEqual [1,2,1] ==> False

allEqual :: [Int] -> Bool
allEqual xs = undefined

5. ülesanne (0.4p)

Kasutades funktsiooni foldr, kirjuta funktsioon unzip', mis jagab paaride listi kaheks eraldi listiks.

Näiteks:

unzip' [(1,'x'), (4,'1'), (2,'p')] == ([1, 4, 2], ['x', '1', 'p'])
unzip' [] == ([], [])

unzip' :: [(a, b)] -> ([a], [b])
unzip' = foldr f b
  where
    b = undefined 
    f = undefined 

6. ülesanne (0.4p)

Genereerida listikomprehensiooniga lõpmatu list, mille elemendid on kasvavas järjestuses selliste paarisarvude kuubid, mille ruudu täisarvulisel jagamisel seitsmega saadakse jääk kaks,

st. 64, 1000 jne. kuna 4^3=64,    4*4 =16,   16 `mod` 7 = 2,
                      10^3=1000, 10*10=100, 100 `mod` 7 = 2.

arvud1 :: [Int]
arvud1 = undefined

7. ülesanne (0.4p)

Defineerida sama list 6. ülesandest, kuid listikomprehensiooni asemel kasutades iterate, filter ja map funktsioone.

arvud2 :: [Int]
arvud2 = undefined

8. ülesanne (0.4p)

Genereerida lõpmatu list elementidega: 0, 1, -1, 2, -2, 3, -3 jne.

hajuvad :: [Int]
hajuvad = undefined

Siin võid ise valida, milliseid vahendeid (rekursioon, kõrgemat järku funktsioonid, listikomprehensioon) ja kuidas kasutad.