FP Cvičení 3

Použití seznamů

Zjistěte jaké jsou výsledky následujících operací:

[3,2,1] > [2,1,0]  
[3,2,1] > [2,10,100]  
[3,4,2] > [3,4]  
[3,4,2] > [2,4]  
[3,4,2] == [3,4,2]

Jednoduché funkce pracující se seznamy

Implementujte následující funkce:

• Vytvořte funkci, která vypočítá délku seznamu.

length' :: [a] -> Int

*Main> length' "ABCD"
4

length' :: [a] -> Int
length' []  = 0
length' (_:xs) = 1 + length' xs

• Vytvořte funkci, která sečte seznam celých čísel.

sumIt :: [Int] -> Int

*Main> sumIt [1,2,3]
6

sumIt :: [Int] -> Int
sumIt []  = 0
sumIt (x:xs) = x + sumIt xs

• Vytvořte funkci která vrátí první prvek v seznamu.

getHead :: [a] -> a

*Main> getHead [1,2,3]
1

getHead :: [a] -> a
getHead (x:_) = x

• Vytvořte funkce která vrátí poslední prvek v seznamu.

getLast :: [a] -> a

*Main> getLast [1,2,3]
3

getLast :: [a] -> a
getLast [x] = x
getLast (x:xs) = getLast xs

getLast' :: [a] -> a
getLast' (x:xs) | length xs == 0 = x
                | otherwise = getLast' xs

• Vytvořte funkci která ověří, zdali je daný prvek obsažen v seznamu.

isElement :: Eq a => a -> [a] -> Bool

*Main> isElement 2 [1,2,3]
True

isElement :: Eq a => a -> [a] -> Bool
isElement _ [] = False
isElement a (x:xs) | a == x = True 
                   | otherwise = isElement a xs

• Vytvořte funkci která vrátí seznam bez prvního prvku.

getTail :: [a] -> [a]

*Main> getTail [1,2,3]
[2,3]

getTail :: [a] -> [a]                   
getTail (_:xs) = xs

• CVytvořte funkci která vátí seznam bez posledního prvku.

getInit :: [a] -> [a]

*Main> getInit [1,2,3]
[1,2]

getInit :: [a] -> [a]
getInit [_] = []
getInit (x:xs) = x : getInit xs

• Vytvořte funkci, která sloučí dva seznamy do jednoho seznamu.

combine :: [a] -> [a] -> [a]

*Main> combine [1,2,3] [4,5]
[1,2,3,4,5]

combine :: [a] -> [a] -> [a]
combine [] y = y
combine (x:xs) y = x : combine xs y

• Vytvořte funkci, která najde maximum v seznamu celých čísel.

max' :: [Int] -> Int

*Main> max' [3,1,7,5]
7

max' :: [Int] -> Int
max' [x] = x
max' (x:y:z) | x > y = max' (x:z)
             | otherwise = max' (y:z)

max'' :: [Int] -> Int
max'' (y:ys) = tmp y ys where
   tmp a [] = a
   tmp a (x:xs) | x > a = tmp x xs 
                |otherwise = tmp a xs

• Vytvořte funkci, která obrátí seznam.

reverse' :: [a] -> [a]

*Main> reverse' [3,1,7,5]
[5,7,1,3]

reverse' :: [a] -> [a]             
reverse' [] = []
reverse' (x:xs) = (reverse' xs) ++ [x]

reverse'' :: [a] -> [a] 
reverse'' n = tmp n  []
  where tmp [] ys = ys 
        tmp (x:xs) ys = tmp xs (x:ys)

• Vytvořte funkci která vrátí skalární součet dvou vektorů.

scalar :: [Int] -> [Int] -> Int

*Main> scalar [1,2,3] [4,5,6]
32

scalar :: [Int] -> [Int] -> Int
scalar [] [] = 0
scalar (x:xs) (y:ys) = x*y + scalar xs ys

Doplňková cvičení

• Vytvořte funkci, která odstraní všechny výskyty nuly v seznamu.

nonZeros :: [Int] -> [Int]

*Main> nonZeros [0,1,0,2,3,0,0]
[1,2,3]

• Vytvořte funkci, která realizuje rotaci seznamu doleva o jeden prvek.

rotateLeft1 :: [a] -> [a]

*Main> rotateLeft1 [1,2,3,4,5]
[2,3,4,5,1]

• Vytvořte funkci, která realizuje prarovou rotaci seznamu o jeden prvek.

rotateRight1 :: [a] -> [a]

*Main> rotateRight1 [1,2,3,4,5]
[5,1,2,3,4]

• Vytvořte funkci, která ze seznamu odstraní všechna sudá čísla.

oddMembers :: [Int] -> [Int]

*Main> oddMembers [0,1,0,2,3,0,0] 
[1,3]

• Vytvořte funkci, která spočítá všechna lichá čísla v daném seznamu (definujte ji nerekurzivně pomocí dříve definovaných funkcí).

countOddMembers :: [Int] -> Int

*Main> countOddMembers [1,0,3,1,4,5]
4

• Vytvořte funkci, která porovnává seznamy čísel, zda se rovnají.

compareLists :: Eq a => [a] -> [a] -> Bool

*Main> compareLists [5,8,11] [5,8,11]
True
*Main> compareLists [5,8,11] [3,5,8]
False
*Main> compareLists [] []
True
*Main> compareLists [5,8,11] [5,8,11,13]
False