lab2

module Lab1 where

data Point = Point Float Float deriving (Show, Eq)
data Pair x y = Pair x y deriving (Show)
firstPair :: Pair x y -> x
firstPair (Pair x y) = x


data Shape = Circle Float Float Float | Rectangle Float Float Float Float
areaShape :: Shape -> Float
areaShape (Circle _ _ r) = pi * r^2
areaShape (Rectangle x1 y1 x2 y2) = abs(x2 - x1) * abs(y2 - y1)

data Color = Red | Green | Blue | RGB Int Int Int
redComponent :: Color -> Int
redComponent Red = 255
redComponent _ = 0

solve :: Float -> Float -> Maybe Float
solve 0 b = Nothing
solve a b = Just (-b/a)

r_sorted:: Int -> [Int]
r_sorted 0  = []
r_sorted n = n:r_sorted (n - 1)

sorted :: Int -> [Int]
sorted n = reverse(r_sorted n)



r_odds :: Int -> [Int]
r_odds 0 = []
r_odds n = if odd n then n:r_odds(n-1) else r_odds(n-1)

odds :: Int -> [Int]
odds n = reverse(r_odds n)

r_evens :: Int -> [Int]
r_evens 0 = []
r_evens n = if even n then n:r_evens(n-1) else r_evens(n-1)

evens :: Int -> [Int]
evens n = reverse(r_evens n)

r_cubes :: Int  -> [Int]
r_cubes 0  = []
r_cubes  n = (n)*(n)*(n):r_cubes (n - 1)

cubes :: Int -> [Int]
cubes n = reverse(r_cubes n)

fact :: (Integral a) => a -> a
fact 0 = 1
fac n = n * fact(n - 1)

r_facts :: Int -> [Int]
r_facts 0 = [1]
r_facts n = (fact n) :r_facts(n-1)

facts :: Int -> [Int]
facts n = reverse(r_facts n)

r_tens :: Int -> [Int]
r_tens (-1) = []
r_tens n = 10^n :r_tens (n - 1)

tens :: Int -> [Int]
tens n = reverse(r_tens n)

treug :: Int -> Int
treug 1 = 1
treug n = n + treug (n-1)
treugs :: Int -> [Int]
treugs 0 = []
treugs x = treugs (x-1) ++ (treug x : [])

piram :: Int -> Int
piram 1 = 1
piram n = treug n + piram (n-1)
pirams :: Int -> [Int]
pirams n = [piram x | x <- [1 .. n]]


avg' :: [Double] -> Double -> Double -> Double
avg' [] n s = s/n
avg' (x:xs) n s = avg' xs (n+1) (s+x)
avg :: [Double] -> Double
avg x = avg' x 0 0

removeItem :: Int -> [Int] -> [Int]
removeItem n (x:xs) = if n == 1 then xs else x : removeItem (n-1) xs

sums :: [Int] -> [Int] -> [Int]
sums [] [] = []
sums (x:xs) [] = x:xs
sums [] (y:ys) = y:ys
sums (x:xs) (y:ys) = (x + y) : sums xs ys

swapEvenOdd :: [Int] -> [Int]
swapEvenOdd [] = []
swapEvenOdd [x] = [x]
swapEvenOdd (x:y:xs) = y : x : swapEvenOdd xs

twopow :: Int -> Int
twopow n | (n == 1) = 2
         | (even n) = w * w
         | otherwise = (w * w) + (w * w)
         where w = twopow (n `div` 2)

removeOdd :: [Int] -> [Int]
removeOdd [] = []
removeOdd (x:xs) = if odd x then removeOdd xs else x : removeOdd xs

removeEmpty :: [String] -> [String]
removeEmpty [] = []
removeEmpty (x:xs) = if x == "" then removeEmpty xs else x : removeEmpty xs



countTrue :: [Bool] -> Integer
countTrue [] = 0
countTrue (x:xs) = if x  then 1 + countTrue xs else countTrue xs

makePositive :: [Int] -> [Int]
makePositive [] = []
makePositive (x:xs) = if x < 0 then (-x) : makePositive xs else x : makePositive xs

delete :: Char -> String -> String
delete _ "" = ""
delete x (y:ys) = if x == y then delete x ys else y : delete x ys

substitute :: Char -> Char -> String -> String
substitute _ _ "" = ""
substitute x y (z:zs) = if x == z then y : substitute x y zs else z : substitute x y zs