Skip to content

← Späť na FP Labs

Cvičenie 1 – Výrazy a funkcie

Useful Files


Ciele

  1. Naučiť sa používať interaktívny interpretátor GHCi.
  2. Naučiť sa definovať vlastné funkcie a používať ich.
  3. Zopakovať si rekurziu a naučiť sa definovať rekurzívne funkcie.
  1. Krok 1: Definícia funkcií a ich aplikácia
  2. Úloha 1.1 – add
  3. Krok 2: Jednoduché funkcie
  4. Úloha 2.1 – hypotenuse
  5. Úloha 2.2 – isLeapYear
  6. Úloha 2.3 – listAverage
  7. Krok 3: Podmienené vykonávanie
  8. Úloha 3.1 – grade
  9. Úloha 3.2 – ticketPrice
  10. Krok 4: Rekurzia
  11. Úloha 4.1 – sumDigits
  12. Úloha 4.2 – isPalindrome
  13. Krok 5: Newtonová metóda
  14. Úloha 5.1 – newtonSqrt

Krok 1: Definícia funkcií a ich aplikácia

Funkcie v jazyku Haskell sa píšu v súbore s príponou .hs. Definícia funkcie má tvar názovFunkcie parametre = výraz.

Haskell je kompilovaný jazyk, ale existuje aj interaktívny interpretátor GHCi, ktorý umožňuje rýchlo skúšať zabudované aj vlastné funkcie. Po spustení GHCi je možné zadávať výrazy a sledovať ich výsledky.

Úloha 1.1 – add

Vytvorte súbor cvicenie.hs a zapíšte doň definíciu funkcie add. Načítajte tento súbor do interaktívneho interpretátora pomocou :load cesta/k/súboru.hs, alebo jeho spustením s názvom súboru ako parametrom (ghci cvicenie.hs). Skúste použiť funkciu add v interpretátore.

add x y = x + y

Krok 2: Jednoduché funkcie

Úloha 2.1 – hypotenuse

Definujte funkciu hypotenuse, ktorá vypočíta dĺžku prepony pravouhlého trojuholníka na základe dĺžok odvesien. Použite pritom funkciu sqrt na výpočet odmocniny a operátor ^ na výpočet druhej mocniny.

Poznámka: Po zmene súboru je možné ho znovu načítať pomocou príkazu :r alebo :reload.

hypotenuse :: Double -> Double -> Double
hypotenuse a b = sqrt (a^2 + b^2)

Úloha 2.2 – isLeapYear

Definujte funkciu isLeapYear, ktorá určí, či zadaný rok je priestupný. Rok je priestupný, ak je deliteľný 4, ale zároveň nie je deliteľný 100, alebo ak je deliteľný 400. Použite bežné logické operátory a funkciu mod na zistenie deliteľnosti.

Poznámka: Funkcie dvoch argumentov je možné používať aj ako operátory, ak sa ich názov uzavrie do spätných apostrofov — napr. 10 `mod` 3 je ekvivalentné mod 10 3.

isLeapYear :: Int -> Bool
isLeapYear year 
  | year `mod` 400 == 0 = True
  | year `mod` 100 == 0 = False
  | year `mod` 4 == 0 = True 
  | otherwise = False

Úloha 2.3 – listAverage

Definujte funkciu average pre výpočet celočíselného aritmetického priemeru zoznamu čísel. Použite pritom funkcie sum (súčet čísel), length (dĺžka zoznamu) a div pre celočíselné delenie.

listAverage :: [Int] -> Int
listAverage xs = sum xs `div` length xs

Krok 3: Podmienené vykonávanie

Podmienené vykonávanie je možné dosiahnuť pomocou tzv. strážcov (guards):

factorial n
    | n == 1 = 1
    | n >= 1 = n * factorial (n-1)

Poznámka: Telo funkcie musí byť odsadené, keďže Haskell, podobne ako Python, používa odsadzovanie ako súčasť syntaxe.

Úloha 3.1 – grade

Definujte funkciu grade, ktorá na základe počtu bodov získaného z predmetu vráti písmenkovú známku (A, B, C, D, E, FX). V prípade neplatného vstupu, nech je výsledkom reťazec "Invalid score".

grade :: Int -> String
grade g
  | g >= 91 && g <= 100 = "A"
  | g >= 81 && g <= 90 = "B"
  | g >= 71 && g <= 80 = "C"
  | g >= 61 && g <= 70 = "D"
  | g >= 51 && g <= 60 = "E"
  | g <= 50 = "FX"

Úloha 3.2 – ticketPrice

Definujte funkciu ticketPrice age, ktorá na základe veku osoby vráti cenu vstupenky do kina. Štandardná cena je 8 eur, pre deti do 15 rokov a seniorov nad 65 rokov je zľava 50%.

ticketPrice :: Int -> Double
ticketPrice age
  | age < 15 || age > 65 = standardPrice * 0.5
  | otherwise = standardPrice
  where standardPrice = 8

Krok 4: Rekurzia

Jedným zo spôsobov, ako riešiť komplexnejšie úlohy, ktoré vyžadujú opakovanie nejakej operácie viackrát, je rekurzia.

Úloha 4.1 – sumDigits

Definujte funkciu sumDigits, ktorá spočíta súčet číslic v zadanom celom čísle (napr. sumDigits 123 == 6).

Poznámka: Na získanie poslednej číslice čísla môžete použiť operáciu mod, na odstránenie poslednej číslice celočíselné delenie div.

sumDigits :: Int -> Int
sumDigits n | n > 0 = n `mod` 10 + sumDigits (n `div` 10)
            | otherwise = 0

Úloha 4.2 – isPalindrome

Definujte funkciu isPalidrome, ktorá určí, či zadané číslo je palindróm (isPalindrome 12345 == False, isPalindrome 1234321 == True).

Poznámka: Definujte ďalšie pomocné funkcie podľa potreby.

isPalindrome :: Int -> Bool
isPalindrome n = s == reverse s
  where
    s = show (abs n)

-- abs n: Ošetrí záporné znamienko (aby z -121 nevzniklo "-121" a "121-").
-- show: Prevedie číslo na String.
-- s == reverse s: Keďže String je obyčajný zoznam ([Char]), funkcia reverse ho priamo otočí a operátor == porovná.

isPalindromeV2 :: Int -> Bool
isPalindromeV2 n = x == reverseNumber x
  where
      x = abs n

reverseNumber :: Int -> Int
reverseNumber n
  | n < 10 = n
  | otherwise = n `mod` 10 * 10^(digits n - 1) + reverseNumber (n `div` 10)

digits :: Int -> Int
digits n
  | n < 10 = 1
  | otherwise = 1 + digits (n `div` 10)

-- n == reverseNumber n: Priamo porovná pôvodné číslo s výsledkom funkcie, ktorá ho otočí.
-- n < 10 = n: Bázový stav rekurzie (guard). Jednociferné číslo je po otočení rovnaké ako na začiatku.
-- n mod 10 * 10^(digits n - 1): Odtrhne poslednú cifru a posunie ju na najvyššiu pozíciu pomocou mocniny 10 (napr. z 123 vezme 3 a spraví 3 * 10^(3-1) = 300).
-- + reverseNumber (n div 10): Rekurzívne otočí zvyšok čísla (12 -> 21) a pripočíta ho k posunutej cifre (300 + 21 = 321).

Krok 5: Newtonová metóda

Na približný výpočet odmocniny je možné použiť Newtonovú metódu. Jej podstata spočíva v postupnom spresňovaní aproximácie. Ak y je odhad hodnoty druhej odmocniny čísla x, tak lepší odhad dokážeme vypočítať ako priemer čísel y a x/y.

Takže v každom kroku výpočtu je možné overiť, či odhad je už dostatočne presný, a ak nie je, vypočítať presnejší. Na overenie nám stačí vypočítať mocninu odhadu y a porovnať ju s odmocňovaným číslom x. Ich rozdiel musí byť menší ako nejaká stanovená hranica.

Úloha 5.1 – newtonSqrt

Definujte funkciu newtonSqrt pre výpočet druhej odmocniny pomocou Newtonovej metódy. Definujte si tiež pomocné funkcie:

  • sqrtIter pre rekurzívne spresňovanie aproximácie,
  • improve pre výpočet lepšej aproximácie,
  • goodEnough pre jej overenie.

Poznámka: Na výpočet absolútnej hodnoty čísla môžete použiť štandardnú funkciu abs.

newtonSqrt :: Double -> Double
newtonSqrt x = sqrtIter 1.0 x

sqrtIter :: Double -> Double -> Double
sqrtIter y x
  | goodEnough y x = y
  | otherwise = sqrtIter (improve y x) x

improve :: Double -> Double -> Double
improve y x = (y + x / y) / 2

goodEnough :: Double -> Double -> Bool
goodEnough y x = abs (y*y - x) < 0.01

-- newtonSqrt x len naštartuje iteráciu s počiatočným odhadom y = 1.0.
-- sqrtIter je rekurzia: ak je odhad dosť presný (goodEnough), vráti ho; inak zavolá samú seba s vylepšeným odhadom (improve y x).
-- improve y x = (y + x/y) / 2 je presne ten vzorec z popisu — priemer y a x/y

Top