Cleaned up 99 problems in haskell. Should go into own repository.

99_problems_001-010.hs

@@ -1,95 +0,0 @@
-import Data.List
-
--- 1 - myLast
-myLast :: [a] -> a
-
-myLast (x:[]) = x
-myLast (x:xs) = myLast xs
-
-myLast' :: [a] -> a
-myLast' = last
-
-myLast'' :: [a] -> a
-myLast'' (x:[]) = x
-myLast'' xs     = myLast'' $ tail xs
-
-
--- 2 - myButLast
-myButLast :: [a] -> a
-
-myButLast (x:y:[]) = x
-myButLast (x:xs) = myButLast xs
-
-myButLast' = head . reverse . init
-
-
--- 3 - elementAt
-elementAt :: [a] -> Int -> a
-
-elementAt (x:_)  1 = x
-elementAt (_:xs) i = elementAt xs (i-1)
-
-elementAt' :: [a] -> Int -> a
-elementAt' xs i = snd . head $ filter (\t -> (fst t) == i) (zip [1..] xs)
-
-
--- 4 - myLength
-myLength :: [a] -> Int
-
-myLength xs = sum [1 | _ <- xs]
-
-myLength' = sum . map (\_ -> 1)
-
-myLength'' = foldr (\_ x -> (x + 1)) 0
-
-myLength''' []     = 0
-myLength''' (x:xs) = 1 + myLength''' xs
-
-
--- 5 - myReverse
-myReverse :: [a] -> [a]
-myReverse = reverse 
-myReverse' = foldr (\x xs -> x:xs)
-
-
--- 6 - isPalindrome
-isPalindrome :: Eq a => [a] -> Bool
-isPalindrome xs = and (zipWith (\x y -> x == y) xs (reverse xs))
-
-
--- 7 - myFlatten
-data NestedList a = Elem a | List [NestedList a]
-  deriving (Show, Read)
-
-
-myFlatten :: (NestedList a) -> [a]
-myFlatten (Elem a)  = [a]
-myFlatten (List xs) = foldl (++) [] (map myFlatten xs)
-
-myFlatten' (Elem a)  = [a]
-myFlatten' (List []) = []
-myFlatten' (List (x:xs)) = foldl (\a b -> (a ++ (myFlatten b))) (myFlatten x) xs
-
-myFlatten'' (Elem a)  = [a]
-myFlatten'' (List xs) = concatMap myFlatten'' xs
-
-
--- 8 - compress
--- compress "aaaabcccaadeeee" -> "abcade"
-compress :: Eq a => [a] -> [a]
-compress []     = []
-compress (x:xs) = reverse $ foldl (\(r:rs) l -> if r == l then r:rs else  l:r:rs) [x] xs
-compress' xs = map head (group xs)
-
-
--- 9 - pack
-pack :: Eq a => [a] -> [[a]]
-pack = group
-
-pack' :: Eq a => [a] -> [[a]]
-pack' [] = []
-pack' xs = (takeWhile (\e -> e == (head xs)) xs):(pack' $ dropWhile (\e -> e == (head xs)) xs)
-
--- 10 - encode
-encode :: Eq a => [a] -> [(Int, a)]
-encode xs = map (\l -> (length l, head l)) $ pack' xs

99_problems_011-020.hs

@@ -1,54 +0,0 @@
-import Data.List
-
--- 11 - encode
-data Encoded a = Single a | Multiple Int a
-  deriving (Show)
-
-encode :: Eq a => [a] -> [(Encoded a)]
-encode xs = map (\l -> if length l > 1 then Multiple (length l) (head l) else Single (head l)) $ group xs
-
-
--- 12 - decode
-decode :: [(Encoded a)] -> [a]
-decode []                  = []
-decode ((Single x):xs)     = x:(decode xs)
-decode ((Multiple n x):xs) = (replicate n x) ++ (decode xs)
-
-
--- 13 - encode - direct
-
-
--- 14 - dupli
-dupli :: [a] -> [a]
-dupli []     = []
-dupli (x:xs) = x:x:(dupli xs)
-
-dupli' xs = concat $ [[x, x] | x <- xs]
-dupli'' = concatMap (\x -> [x, x])
-
-
--- 15 - repli
-repli :: [a] -> Int -> [a]
-repli xs n = concatMap (\x -> replicate n x) xs
-
-
--- 16 - dropEvery
-dropEvery :: [a] -> Int -> [a]
-dropEvery [] _     = []
-dropEvery xs n = (take (n-1) xs) ++ dropEvery (drop n xs) n
-
-
--- 17 - split
-split :: [a] -> Int -> ([a], [a])
-split xs n = (take n xs, drop n xs)
-
-
--- 18 - slice
-slice :: [a] -> Int -> Int -> [a]
-slice xs l u = take (u-l+1) $ drop (l-1) xs
--- not mine: slice xs i k = [x | (x,j) <- zip xs [1..k], i <= j]
-
-
--- 19 - rotate
-rotate :: [a] -> Int -> [a]
-rotate xs _ = []