1. kodused ülesanded

Üldinfo

Lahenduste esitamise tähtaeg on 12.10. Lahendused saata mailiga kas varmo@cs.ut.ee või nestra@cs.ut.ee (sõltuvalt sellest, millises praktikumi rühmas olete); subjektiks peab olema fpkodu1. Iga ülesande eest on võimalik saada kuni 10 punkti (seega kokku kuni 50 punkti). Hilinenud lahenduste korral väheneb punkti summa 10% iga hilinenud päeva kohta. Näiteks, kui lahendus on väärt 50 punkti, aga jõuab meieni 14.10 (so. kaks päeva hiljem), siis on tegelik punktisumma 50 * 0.9^2 = 41.

Vormistamisest

Kõigi ülesannete lahendused vormistada ühe Haskelli failina. Faili nimi peab olema FPkodu1.hs ning seal defineeritava mooduli nimi FPkodu1. Faili algusse lisada kommentaaridena kõigi rühmaliikmete nimed (rühmas võib olla max. 4 liiget, kusjuures kõigil peab olema sama praktikumi juhendaja) ja maili-aadressid. Kõigi ülesannete korral peavad protseduuride nimed ja argumentide arv/järjekord vastama täpselt ülesandes esitatule. Lahendused peavad olema loetavad ja piisavalt kommenteeritud (sh. kui kasutate abiprotseduure, siis see mida nad teevad peab olema selgelt välja toodud). Näiteks (FPkodu1.hs):

module FPkodu1 where

---------------------------------------------------------------------
-- FPkodu1.hs
-- Funktsionaalprogrammeerimise meetod - 1. koduülesannete lahendused
--
-- Autorid:
--          Jaan    Tatikas   (tatikas@ut.ee)
--          Salomon Vesipruul (salomon@ut.ee)
---------------------------------------------------------------------

-- 1. ülesanne - Funktsioon isOrderedBy kontrollib, kas ...

isOrderedBy :: (a -> a -> Bool) -> [a] -> Bool
isOrderedBy p xs = ...

Ülesanded

  1. Kirjutada funktsioon isOrderedBy, mis kontrollib, kas list on etteantud järjestusfunktsiooni suhtes järjestatud.
    > isOrderedBy :: (a -> a -> Bool) -> [a] -> Bool
    
    Näiteks:
    isOrderedBy (<)  [1,2,3,4]  ==>  True
    isOrderedBy (<)  [1,1,2,3]  ==>  False
    isOrderedBy (<=) [1,1,2,3]  ==>  True
    isOrderedBy (>)  [1,2,3,4]  ==>  False
    isOrderedBy (>)  []         ==>  True
    
  2. Funktsioon countDropWhile eemaldab listi algusest elemente niikaua kuni argumenttingimus on täidetud ja väljastab ülejäänud listi ning äravisatud elementide arvu:
    > countDropWhile :: (a -> Bool) -> [a] -> ([a],Int)
    
    Näiteks:
    countDropWhile (>5) [9,7,6,4,14,2,1]  ==>  ([4,14,2,1],3)
    
    so. funktsioon countDropWhile on defineeritav kui:
    countDropWhile p xs = (dropWhile p xs, length (takeWhile p xs))
    
    Kirjutage funktsiooni countDropWhile definitsioon, mis on otserekursiivne ja vaatab argumentlisti läbi ainult üks kord.
  3. Funktsioon countFilter eemaldab listist kõik need elemendid mille korral argumenttingimus ei ole täidetud ja väljastab ülejäänud listi ning äravisatud elementide arvu:
    > countFilter :: (a -> Bool) -> [a] -> ([a],Int)
    
    Näiteks:
    countFilter (>5) [9,7,6,4,14,2,1]  ==>  ([9,7,6,14],3)
    
    so. funktsioon countFilter on defineeritav kui:
    countFilter p xs = (filter p xs, length xs - length (filter p xs))
    
    Kirjutage funktsiooni countFilter definitsioon kasutades standardfunktsiooni foldr:
    > countFilter p xs = foldr f b xs
    >         where f ...
    >               b ...
    
  4. Kirjutada funktsioon diffProd, mis etteantud täisarvude listist [X1, X2, ..., Xn] arvutab kõikvõimalike vahede Xi - Xj (i < j) korrutise; so korrutise kujul (X1 - X2) * (X1 - X3) * ... * (X1 - Xn) * (X2 - X3) * ... * (Xn-1 - Xn)
    > diffProd :: [Integer] -> Integer
    
    Näiteks:
    diffProd []      ==>   1
    diffProd [4]     ==>   1
    diffProd [4,2]   ==>   2
    diffProd [4,2,3] ==>  -2
    
  5. Kirjutada funktsioon suffle, mis saades argumendiks listi, paigutab selle elemendid ringi selliselt, et esimene element läheb esimeseks, viimane teiseks, teine kolmandaks, tagant teine neljandaks, jne.
    > suffle :: [a] -> [a]
    
    Näiteks:
    suffle []      ==>  []
    suffle [1]     ==>  [1]
    suffle [1,2]   ==>  [1,2]
    suffle [1,2,3] ==>  [1,3,2]
    suffle [1..4]  ==>  [1,4,2,3]
    suffle [1..5]  ==>  [1,5,2,4,3]
    

Varmo Vene