Лабораторная №2 Haskell

-------------------------------------
---------------ЧАСТЬ 1---------------
-------------------------------------

-- Задача №1

--1-ый способ:
fun11 :: Int -> [Int]
fun11 n = [1..n]

--2-ой способ:
fun12 :: Int -> [Int]
fun12 0 = []
fun12 n = fun12 (n - 1) ++ [n]

-- Задача №2

--1-ый способ:
fun21 :: Int -> [Int]
fun21 n = [1, 3..2*n]

--2-ой способ:
fun22 :: Int -> [Int]
fun22 n = filter odd [1..2*n]

--3-ий способ:
fun23 :: Int -> [Int]
fun23 n = map ( (+(-1)) . (*2) ) [1..n]

--4-ый способ:
fun24 :: Int -> [Int]
fun24 n = [2*x - 1 | x <- [1..n]]

--5-ый способ:
fun25 :: Int -> [Int]
fun25 n = filter odd $ helper (2*n)
    where helper 0 = []
          helper n = helper (n - 1) ++ [n]

--6-ой способ:
fun26 :: Int -> [Int]
fun26 n
    | n == 0 = []
    | odd n = fun26 (n - 1) ++ [n]
    | otherwise = fun26 (n - 1)

-- Задача №3

--1-ый способ:
fun31 :: Int -> [Int]
fun31 n = [2, 4..2*n]

--2-ой способ:
fun32 :: Int -> [Int]
fun32 n = filter even [1..2*n]

--3-ий способ:
fun33 :: Int -> [Int]
fun33 n = map (*2) [1..n]

--4-ый способ:
fun34 :: Int -> [Int]
fun34 n = [2*x | x <- [1..n]]

--5-ый способ:
fun35 :: Int -> [Int]
fun35 n = filter even $ helper (2*n)
    where helper 0 = []
          helper n = helper (n - 1) ++ [n]

--6-ой способ:
fun36 :: Int -> [Int]
fun36 n
    | n == 0 = []
    | even n = fun36 (n - 1) ++ [n]
    | otherwise = fun36 (n - 1)

-- Задача №4

--1-ый способ:
fun41 :: Int -> [Int]
fun41 n = map (^2) [1..n]

--2-ой способ:
fun42 :: Int -> [Int]
fun42 n = [x^2 | x <- [1..n]]

--3-ий способ:
fun43 :: Int -> [Int]
fun43 0 = []
fun43 n = fun43 (n - 1) ++ [n^2]

-- Задача №5

--1-ый способ:
fun51 :: Int -> [Int]
fun51 n = [product[1..x] | x <- [1..n]]

 --2-ой способ:
fun52 :: Int -> [Int]
fun52 n = take n $ iterate (\x -> product[1..x]) 1

--3-ий способ:
fun53 :: Int -> [Int]
fun53 n = map factorial [1..n] -- map (\x -> product [1..x]) [1..n]
    where factorial x = product [1..x] --можно было описать анонимную функцию, как и во 2-ом способе

--4-ый способ:
fun54 :: Int -> [Int]
fun54 0 = []
fun54 n = fun54 (n - 1) ++ [factorial]
    where factorial = product [1..n]

-- Задача №6

--1-ый способ:
fun61 :: Int -> [Int]
fun61 n = [2^x | x <- [1..n]]

--2-ой способ:
fun62 :: Int -> [Int]
fun62 n = take n $ iterate(*2) 1

--3-ий способ:
fun63 :: Int -> [Int]
fun63 n = map degree [1..n] -- map (\x -> 2^x) [1..n]
    where degree x = 2^x --можно было описать анонимную функцию

--4-ый способ:
fun64 :: Int -> [Int]
fun64 0 = []
fun64 n = fun64 (n - 1) ++ [degree]
    where degree = 2^n

-------------------------------------
---------------ЧАСТЬ 2---------------
-------------------------------------

-- Задача №1
fun1 :: [Float] -> Float
fun1 x = uncurry (/) (helper x)
    where helper [] = (0, 0)
          helper  x = sumPair (head x, 1) (helper $ tail x)
          sumPair (a, b) (c, d) = (a + c, b + d)

-- Задача №2

--1-ый способ:
fun21 :: [a] -> Int -> a
fun21 x n = x !! (n - 1)

--2-ой способ:
fun22 :: [a] -> Int -> a
fun22 x 1 = head x
fun22 x n = (fun22 $ tail x) (n - 1)

-- Задача №3

--1-ый способ:
fun31 :: Num a => [a] -> [a] -> [a]
fun31 = zipWith (+)

--2-ой способ:
fun32 :: Num a => [a] -> [a] -> [a]
fun32 [] [] = []
fun32 []  y = head y : fun32 [] (tail y)
fun32 x  [] = head x : fun32 (tail x) []
fun32 x   y = head x + head y : fun32 (tail x) (tail y)

-- Задача №4
fun4 :: [a] -> [a]
fun4 [] = []
fun4 [a] = [a]
fun4 x = [head $ tail x, head x] ++ fun4 (tail $ tail x)

--Задача №5
tpowpow :: Int -> Int -> Int
tpowpow a 0 = 1
tpowpow a n = if odd n then a * tpowpow (a^2) (div n 2) else tpowpow (a^2) (div n 2)

--Задача №6
removeOdd :: [Int] -> [Int]
removeOdd = filter even

--Задача №7

--1-ый способ:
removeEmpty1 :: [String] -> [String]
removeEmpty1 = filter (/= "")

--2-ой способ:
removeEmpty2 :: [String] -> [String]
removeEmpty2 s = [x | x <- s, x /= ""]

--Задача №8

--1-ый способ:
countTrue1 :: [Bool] -> Int
countTrue1 s = sum $ map (\i -> if i then 1 else 0) s

--2-ой способ:
countTrue2 :: [Bool] -> Int
countTrue2 [] = 0
countTrue2 (x : xs)
    | x = 1 + countTrue2 xs
    | otherwise = countTrue2 xs

--Задача №9
makePositive :: Num a => [a] -> [a]
makePositive = map abs

--Задача №10

--1-ый способ:
delete1 :: Char -> String -> String
delete1 a = filter (/= a)

--2-ой способ:
delete2 :: Char -> String -> String
delete2 a s = [x | x <- s, x /= a]

--Задача №11
substitute :: Char -> Char -> String -> String
substitute a b = map (\x -> if x == a then b else x)