import Data.Char (toLower) -- https://hackage-content.haskell.org/package/base-4.22.0.0/docs/Data-List.html {- Základné operátory a funkcie pre prácu s zoznamami: Konštruktory: [] :: [a] (:) :: a -> [a] -> [a] Operátory: (++) :: [a] -> [a] -> [a] (!!) :: [a] -> Int -> a Funkcie: head :: [a] -> a tail :: [a] -> [a] last :: [a] -> a init :: [a] -> [a] length :: [a] -> Int null :: [a] -> Bool reverse :: [a] -> [a] take :: Int -> [a] -> [a] drop :: Int -> [a] -> [a] elem :: Eq a => a -> [a] -> Bool -} -- Labs -- 1. -- Úloha 1.1 -- Definujte funkciu rotateRight realizujúcu cyklický posun doprava o zadaný počet pozícií. Použite pritom len funkcie uvedené vyššie. -- rotateRight :: Int -> [a] -> [a] -- Príklady použitia: -- rotateRight 2 [1, 2, 3, 4, 5] == [4, 5, 1, 2, 3] -- rotateRight 3 "abcdef" == "defabc" -- rotateRight 0 [1, 2, 3] == [1, 2, 3 rotateRight :: Int -> [a] -> [a] rotateRight n xs = drop k xs ++ take k xs where k = (length xs - n) `mod` length xs ---------------------------------------------- -- Krok 2: Porovnávanie vzorov cieľ 2 -- V niektorých prípadoch je možné definovať funkciu viacerými rovnicami, kde namiesto názvov parametrov budú uvedené vzory. Pri výbere rovnice, ktorá sa použije skutočné hodnoty parametrov sa postupne porovnávajú so vzormi až kým sa nenájde taký vzor, ktorý je možné s hodnotou stotožniť. Tento prístup sa nazýva pattern matching. -- isOne 1 = True -- isOne n = False -- Úloha 2.1 -- Definujte funkciu myReplicate s dvoma parametrami: číslom a ľubovoľnou hodnotou. Funkcia vytvorí zoznam opakovaním hodnoty. Nepoužívajte pritom funkciu replicate zo štandardnej knižnice. -- myReplicate :: Int -> a -> [a] -- Príklady použitia: -- myReplicate 4 8 == [8, 8, 8, 8] -- myReplicate 3 'a' == "aaa" -- Konštruktory dátovej štruktúry je možné použiť vo vzoroch na ľavej strane rovníc definujúcich funkcie: -- mySum :: [Integer] -> Integer -- mySum [] = 0 -- mySum (x:xs) = x + mySum xs myReplicate :: Int -> a -> [a] -- myReplicate n x = map (const x) [1..n] myReplicate 0 _ = [] myReplicate n x = x : myReplicate(n-1)x ---------------------------------------------- -- Úloha 2.2 -- Definujte funkciu count, ktorý spočíta vyskyty zadaného prvku v zozname. Použite porovnávanie vzorov a rekurziu. -- count :: Eq a => a -> [a] -> Int -- Príklad: -- count 'r' "raspberry" count :: Eq a => a -> [a] -> Int count _ [] = 0 count p (currentLetter:word) | p == currentLetter = 1 + count p word | otherwise = count p word -- using filter -- count :: Eq a => a -> [a] -> Int -- count e xs = length (filter (== e) xs) -- using map -- count :: Eq a => a -> [a] -> Int -- count e xs = sum (map (\x -> if x == e then 1 else 0) xs) ---------------------------------------------- -- Úloha 2.3 -- Definujte funkciu compress, ktorá vytvorí zoznam, v ktorom budú vynechané duplicitné prvky idúce bezprostredne po sebe. -- compress :: Eq a => [a] -> [a] -- Príklad: -- compress "aaabbbccdaa" == "abcda" compress :: Eq a => [a] -> [a] compress (x:y:xs) | x == y = compress (y:xs) | otherwise = x : compress (y:xs) compress xs = xs ---------------------------------------------- -- Úloha 2.4 -- Definujte funkciu merge, ktorá zlúči dva usporiadané zoznamy do jedného usporiadaného zoznamu. -- merge :: Ord a => [a] -> [a] -> [a] -- Príklad: -- merge [1, 3, 6, 8, 9] [2, 4, 5, 7] == [1, 2, 3, 4, 5, 6, 7, 8, 9] merge :: Ord a => [a] -> [a] -> [a] merge xs [] = xs merge [] ys = ys merge l@(x:xs) r@(y:ys) | x < y = x : merge xs r | otherwise = y : merge l ys ---------------------------------------------- -- 3 -- Funkcie vyššieho rádu pre prácu s zoznamami cieľ 3 ---------------------------------------------- -- Typické spôsoby manipulácie s zoznamami, ako je upravenie každého prvku, alebo výber časti prvkov na základe nejakého kritéria, sú realizované pomocou funkcií vyššieho rádu map a filter. Ich typové definície sú nasledovné: -- map :: (a -> b) -> [a] -> [b] -- filter :: (a -> Bool) -> [a] -> [a] -- Pokuste sa využiť tieto funkcie pri riešení nasledujúcich úloh. -- Úloha 3.1 -- Definujte funkciu wordLengths, ktorá vráti zoznam dĺžok jednotlivých slov zozname. -- wordLengths :: [String] -> [Int] -- wordLengths ["functional", "programming", "is", "fun"] == [10, 11, 2, 3] wordLengths :: [String] -> [Int] wordLengths ws = map length ws -- map length ["functional", "programming", "is", "fun"] -- = [length "functional", length "programming", length "is", length "fun"] -- = [10, 11, 2, 3] -- Výsledok: wordLengths ["functional", "programming", "is", "fun"] == [10, 11, 2, 3] ✓ -- Dá sa to zapísať aj bez pomenovaného parametra ws (point-free štýl): -- wordLengths :: [String] -> [Int] -- wordLengths = map length ---------------------------------------------- -- Úloha 3.2 -- Definujte funkciu inRange, ktorá vyberie zo zoznmu iba čísla v zadanom rozsahu (vrátane hraničných hodnôt). -- inRange :: Int -> Int -> [Int] -> [Int] -- inRange 3 7 [1,3,8,5,7,2] == [3,5,7] inRange :: Int -> Int -> [Int] -> [Int] inRange min max xs = filter isInRange xs where isInRange x = x >= min && x <= max -- filter isInRange x = x >= min && x <= max [1,3,8,5,7,2] -- x=1: 1>=3 → False → vynechá -- x=3: 3>=3 && 3<=7 → True → ponechá -- x=8: 8>=3 && 8<=7 → False (8<=7 je False) → vynechá -- x=5: 5>=3 && 5<=7 → True → ponechá -- x=7: 7>=3 && 7<=7 → True → ponechá -- x=2: 2>=3 → False → vynechá -- výsledok = [3,5,7] -- Výsledok: isInRange 3 7 [1,3,8,5,7,2] == [3,5,7] ✓ ---------------------------------------------- -- Úloha 3.3 -- Definujte funkciu passingStudents, ktorá vyberie zo zoznamu študentov tých, ktorí získali viac ako 50 bodov. Každý študent je reprezentovaný dvojicou, kde prvý prvok je meno študenta a druhý počet bodov. -- passingStudents :: [(String, Int)] -> [String] -- passingStudents [("Eva",72), ("Adam",43), ("Mia",50), ("John",60)] == ["Eva","John"] passingStudents :: [(String, Int)] -> [String] -- fst - returns the first element of a pair passingStudents students = map fst (filter passing students) where passing (name, score) = score > 50 -- filter ((name,score) -> score > 50) [("Eva",72),("Adam",43),("Mia",50),("John",60)] -- ("Eva",72): 72 > 50 → True → ponechá -- ("Adam",43): 43 > 50 → False → vynechá -- ("Mia",50): 50 > 50 → False (nie je ostro väčšie!) → vynechá -- ("John",60): 60 > 50 → True → ponechá -- = [("Eva",72), ("John",60)] -- map fst [("Eva",72), ("John",60)] -- = [fst ("Eva",72), fst ("John",60)] -- = ["Eva", "John"] ---------------------------------------------- -- Úloha 3.4 -- Definujte funkciu normalizeNames, ktorá prevedie všetky mená na malé písmená a vynechá prázdne mená. -- normalizeNames :: [String] -> [String] -- normalizeNames ["Alice", "", "Bob"] == ["alice", "bob"] -- Použite pritom aj funkciu toLower z modulu Data.Char, ktorý musíte importovať: -- import Data.Char (toLower) normalizeNames :: [String] -> [String] normalizeNames names = map (map toLower) (filter (not . null) names) -- Keďže String = [Char], na prevod celého slova na malé písmená potrebuješ toLower aplikovať na každý znak slova — teda map toLower :: String -> String. A keďže chceme toto urobiť pre každé slovo v zozname, obalíme to ešte jedným map: map (map toLower) :: [String] -> [String]. -- Prečo filter (not . null): null :: [a] -> Bool vráti True pre prázdny zoznam (teda aj prázdny reťazec ""). Chceme ale ponechať neprázdne mená, takže potrebujeme opak — not . null (zložená funkcia: najprv null, potom neguj výsledok cez not). -- Krok po kroku na normalizeNames ["Alice", "", "Bob"]: -- filter (not . null) ["Alice", "", "Bob"] -- "Alice": null "Alice" = False → not False = True → ponechá -- "": null "" = True → not True = False → vynechá -- "Bob": null "Bob" = False → not False = True → ponechá -- = ["Alice", "Bob"] -- map (map toLower) ["Alice", "Bob"] -- map toLower "Alice" = "alice" -- map toLower "Bob" = "bob" -- = ["alice", "bob"] ---------------------------------------------- -- Úloha 3.5 -- Definujte funkciu getValue, ktorej prvým argumentom je zoznam tovarov. Tie sú reprezentované dvojicou. Prvý prvok dvojice je názov výrobcu a druhý hodnota konkrétneho tovaru. Jednotlivý výrobca môže byť v zozname viackrát. Vašou úlohou je vypočítať výslednú sumu za všetky tovary od výrobcu, ktorý je určený druhým parametrom. products :: [(String, Int)] products = [("avia",1000), ("trabant",500), ("avia",400), ("tatra",600), ("trabant",200), ("avia",700)] -- getValue :: [(String, Int)] -> String -> Int -- getValue products "trabant" == 700 -- Poznámka -- Vo funkcii použite funkcie vyššieho rádu ako sú map a filter. Okrem toho môžete použiť funkciu sum, ktorá vypočíta súčet prvkov zoznamu čísel. -- snd - returns the second element of a pair getValue :: [(String, Int)] -> String -> Int getValue products manufacturer = sum (map snd matching) where matching = filter sameManufacturer products sameManufacturer (name, _) = name == manufacturer -- filter sameManufacturer ((name, _) -> name == manufacturer) products ponechá len tie dvojice, kde meno výrobcu sedí so zadaným manufacturer. -- map snd z každej ponechanej dvojice vezme len hodnotu (druhý prvok tuple), zahodí meno. -- sum spočíta všetky tieto hodnoty dokopy. -- Krok po kroku na getValue products "trabant" (kde products = [("avia",1000), ("trabant",500), ("avia",400), ("tatra",600), ("trabant",200), ("avia",700)]): -- filter (\(name,value) -> name == "trabant") products -- ("avia",1000): "avia"=="trabant" → False → vynechá -- ("trabant",500): "trabant"=="trabant" → True → ponechá -- ("avia",400): "avia"=="trabant" → False → vynechá -- ("tatra",600): "tatra"=="trabant" → False → vynechá -- ("trabant",200): "trabant"=="trabant" → True → ponechá -- ("avia",700): "avia"=="trabant" → False → vynechá -- = [("trabant",500), ("trabant",200)] -- map snd [("trabant",500), ("trabant",200)] -- = [500, 200] -- sum [500, 200] = 700 ---------------------------------------------- -- Úloha 3.6 -- Definujte funkciu replace, ktorá nahradí slova v texte podľa zadaného zoznamu náhrad. Funkcia má nahradzovať len celé slová, nie ich časti. Môžete pritom použiť zabudované funkcie words a unwords. replacements = [("fox", "cat"), ("he", "she"), ("dog", "crocodile")] sentence = "The quick brown fox jumps over the lazy dog" -- replace replacements sentence == "The quick brown cat jumps over the lazy crocodile" -- unwords - joins a list of words back into a single string, separated by spaces -- words - splits a string into a list of words, separated by whitespace -- Just - Just x means a value was found (x) -- Nothing - Nothing means no value found -- lookup - lookup key assocs looks up a key in an association list. For the result to be Nothing, the list must be finite. replace :: [(String, String)] -> String -> String replace replacements sentense = unwords (map replaceWord (words sentense)) where replaceWord w = case lookup w replacements of Just newWord -> newWord Nothing -> w -- words text rozdelí vetu na zoznam jednotlivých slov — to je dôležité, lebo tým zabezpečíme, že nahrádzame celé slová, nie časti slov (inak by sme napr. "fox" mohli nahradiť aj vnútri dlhšieho slova ako "foxglove"). -- lookup :: Eq a => a -> [(a, b)] -> Maybe b je vstavaná funkcia, ktorá v zozname dvojíc nájde hodnotu zodpovedajúcu danému kľúču. Ak kľúč nájde, vráti Just hodnota; ak nie, vráti Nothing. -- replaceWord pre každé slovo w skontroluje, či sa nachádza medzi náhradami: ak áno (Just newWord), použije náhradu; ak nie (Nothing), ponechá pôvodné slovo w. -- unwords spojí upravený zoznam slov naspäť do vety (oddelené medzerami). -- Krok po kroku na replace [("fox","cat"), ("he","she"), ("dog","crocodile")] "The quick brown fox jumps over the lazy dog": -- words "The quick brown fox jumps over the lazy dog" -- = ["The","quick","brown","fox","jumps","over","the","lazy","dog"] -- map replaceWord [...]: -- "The" -> lookup "The" replacements = Nothing -> "The" (veľké T sa nezhoduje s "the") -- "quick" -> Nothing -> "quick" -- "brown" -> Nothing -> "brown" -- "fox" -> lookup "fox" replacements = Just "cat" -> "cat" -- "jumps" -> Nothing -> "jumps" -- "over" -> Nothing -> "over" -- "the" -> lookup "the" replacements = Nothing -> "the" ("he" sa nehľadá ako podreťazec!) -- "lazy" -> Nothing -> "lazy" -- "dog" -> lookup "dog" replacements = Just "crocodile" -> "crocodile" -- = ["The","quick","brown","cat","jumps","over","the","lazy","crocodile"] -- unwords [...] -- = "The quick brown cat jumps over the lazy crocodile" ---------------------------------------------- -- main (to run this code: bash> ./start) main :: IO () main = do -- 1.1 -- print (rotateRight 13 [1,2,3,4,5,6]) -- 2.1 -- print (myReplicate 4 'a') -- 2.2 -- print (count 'a' "banan") -- 2.3 -- print (compress "bannan") -- 2.4 -- print (merge [1,2,3] [4,5,6]) -- 3 -- 3.1 -- print (wordLengths ["functional", "programming", "is", "fun"]) -- 3.2 -- print (inRange 3 7 [1,3,8,5,7,2]) -- 3.3 -- print (passingStudents [("Eva",72), ("Adam",43), ("Mia",50), ("John",60)]) -- 3.4 -- print (normalizeNames ["Alice", "", "Bob"]) -- 3.5 -- print (getValue products "trabant") -- 3.6 print (replace replacements sentence)