haskell_wszystkie_zadania

=================LAB5=================

Zdefiniuj funkcje obliczające kwadrat podanego parametru. Funkcje powinny zwracać taki
sam typ jak typ wejściowy. Po zapisaniu i załadowaniu modułu sprawdź zdefiniowane
funkcje.

kwadratI :: Int -> Int
kwadratI x = x * x

kwadratF :: Float -> Float
kwadratF x = x * x

kwadratN :: Num a => a -> a
kwadratN x = x * x

kwadrat x = x * x

=================LAB6=================

negacja :: Int -> Int
negacja x = -x

Napisz funkcję obliczającą deltę oraz pierwiastek dla równania kwadratowego postaci
y=ax^2+bx+c. Użyj dwóch funkcji delta i pdelta

pier :: Int -> Float
pier x = if x > 0 then sqrt (fromIntegral x) else error "liczba ujemna"
-----------
delta :: Double -> Double -> Double -> Double
delta a b c = b * b - 4 * a * c

pdelta :: Double -> Double -> Double -> Double
pdelta a b c = sqrt (delta a b c)
----------
delta :: Double -> Double -> Double -> Double
delta a b c = b * b - 4 * a * c

pdelta :: Double -> Double -> Double -> Double
pdelta a b c = if warunek > 0
               then sqrt (delta a b c)
               else if warunek == 0
                    then 0
                    else error "delta jest mniejsza od zera"
                    where warunek = (delta a b c)
----------
delta :: Double -> Double -> Double -> Double
delta a b c = b * b - 4 * a * c

pdelta :: Double -> Double -> Double -> [Double]
pdelta a b c = if a == 0
               then error "nie jest mozliwe dzielenie przez 0"
               else if(delta a b c) == 0
                    then [(-b) / (2 * a)]
                    else if (delta a b c) > 0
                         then [(-b + pier) / (2 * a),
                               (-b - pier) / (2 * a)]
                         else error "delta jest mniejsza od zera, brak pierwiastkow"
               where pier = sqrt (delta a b c)

=================LAB7=================

sign2 n
   | n < 0 = "-"
   | n > 0 = "+"
   | n == 0 = "zero"
   | otherwise = "error"

sign1 0 = "zero"
sign1 n = case n > 0 of
   True -> "+"
   False -> "-"

myComp :: Ord a => a -> a -> Ordering
myComp a b
   | a > b = GT
   | a < b = LT
   | a == b = EQ
-----------------------------------------------

Napisz samodzielnie poprawniej działającą
wersję mnożenia.

mul1 :: Int -> Int -> Int
mul1 a 1 = a
mul1 1 a = a
mul1 _ 0 = 0
mul1 0 _ = 0
mul1 a b
   | (a < 0) && (b < 0) = mul1 (-a) (-b)
   | b > 0 = a + mul1 a (b-1)
   | b < 0 = b + mul1 b (a-1)

mul1 :: Int ->Int ->Int
mul1 a 0 = 0
mul1 a 1 = a
mul1 a b = if b>0 then a + mul1 a (b-1)
    else -(a + mul1 a ((-b)-1))

Napisz funkcje obliczającą wartość silni. Użyj rekurencji, konstrukcji ze strażnikami,
konstrukcji warunkowej lub case.

silnia :: Int -> Int
silnia 0 = 1
silnia n = case n > 0 of
   True -> n * silnia (n - 1)
   False -> error "liczba <0"

Napisz funkcję obliczającą kolejne elementy ciągu Fibonacciego.

fibb 1 = 1
fibb 2 = 1
fibb a = case a>0 of
  True -> fibb(a-1)+fibb(a-2)
  False -> error "cos poszlo nie tak"


=================LAB8=================

Napisz funkcję obliczającą iloczyn elementów listy, użyj foldr

fun :: [Int] -> Int
fun x = foldr (*) 1 x

Napisz funkcję sprawdzającą czy podany znak jest dużą literą. Użyj elem.

litera a = if elem a ['a'..'z'] then "mala litera"
   else if elem a ['A'..'Z'] then "duza litera"
      else error "nie litera"

Napisz funkcję usuwającą z napisu duże litery. Napis to lista znaków.

usun napis = [ c | c <- napis, not(c `elem` ['A'..'Z'])]

Napisz kod programu, który ze wszystkich możliwych trójek (a, b, c) wygeneruje tylko te, dla
których a^2 + b ^ 2 = c ^ 2, tak zwane trójki pitagorejskie. Wartości a,b,c należą do przedziału
od 0 do 20. Użyj list comprehensions.

pitagoras = [[a,b,c] | a <- [0..20], b <- [0..20], c <- [0..20], a*a+b*b==c*c]

Napisz funkcję obliczającą silnię dla liczb parzystych w zakresie od 1 do 20. Użyj funkcji map,
filter, where, even, mod i specyfikacji zasięgu listy.

factorial :: Integer -> Integer
factorial 0 = 1
factorial n = n * factorial (n - 1)

--silnia = map factorial (filter even1 [1..20]) where even1 x = mod x 2 == 0
silnia = map (\x -> factorial x) (filter (even) [1..20])

Napisz funkcje obliczającą kwadraty kolejnych liczb naturalnych przedziale od 0 do 20. Użyj
map i where. Następnie drugi program z map i funkcję lambda.

doKwadratu = map (\x -> x * x) [1..20]

Napisz kod, który zwróci największą wartość poniżej 1000000 podzielną przez 3829 bez
reszty.

rev :: [Int] -> [Int]
rev [] = []
rev x = last x : rev (init x)
lista = rev [3829..999999]
lista2 = filter (\x -> x `mod` 3829 == 0) lista
wartosc = take 1 lista2

Napisz funkcję obliczającą liczbę wszystkich nieparzystych kwadratów liczb od 1 do 10000.
Do obliczeń możesz wykorzystać takeWhile, sum, odd, map, filter, length.

listaKwadratow = filter (odd) (map (\x -> x * x) [1..10000])
doKwadratu = length listaKwadratow