-
-
Save erdOne/0e6b748cb82ddfbb1034cec6a61de638 to your computer and use it in GitHub Desktop.
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| -- This exercise covers the first 6 chapters of "Learn You a Haskell for Great Good!" | |
| -- Chapter 1 - http://learnyouahaskell.com/introduction | |
| -- Chapter 2 - http://learnyouahaskell.com/starting-out | |
| -- Chapter 3 - http://learnyouahaskell.com/types-and-typeclasses | |
| -- Chapter 4 - http://learnyouahaskell.com/syntax-in-functions | |
| -- Chapter 5 - http://learnyouahaskell.com/recursion | |
| -- Chapter 6 - http://learnyouahaskell.com/higher-order-functions | |
| -- Download this file and then type ":l Chapter-1-6.hs" in GHCi to load this exercise | |
| -- Some of the definitions are left "undefined", you should replace them with your answers. | |
| import Data.Tuple(swap) | |
| import Data.List(sortOn) | |
| -- Find the penultimate (second-to-last) element in list xs | |
| penultimate xs = last (init xs) | |
| -- Find the antepenultimate (third-to-last) element in list xs | |
| antepenultimate = last . init . init | |
| -- Left shift list xs by 1 | |
| -- For example, "shiftLeft [1, 2, 3]" should return "[2, 3, 1]" | |
| shiftLeft (x:xs) = xs ++ [x] | |
| -- Left shift list xs by n | |
| -- For example, "rotateLeft 2 [1, 2, 3]" should return "[3, 1, 2]" | |
| rotateLeft n xs = (iterate shiftLeft xs) !! n | |
| -- Insert element x in list xs at index k | |
| -- For example, "insertElem 100 3 [0,0,0,0,0]" should return [0,0,0,100,0,0] | |
| insertElem x k xs = let (a, b) = splitAt k xs in a ++ [k] ++ b | |
| -- Here we have a type for the 7 days of the week | |
| -- Try typeclass functions like "show" or "maxBound" on them | |
| data Day = Mon | Tue | Wed | Thu | Fri | Sat | Sun | |
| deriving (Eq, Ord, Show, Bounded, Enum) | |
| -- Note that if you try "succ Sun", you should get an error, because "succ" is not defined on "Sun" | |
| -- Define "next", which is like "succ", but returns "Mon" on "next Sun" | |
| next :: Day -> Day | |
| next Sun = Mon | |
| next d = succ d | |
| -- Return "True" on weekend | |
| isWeekend :: Day -> Bool | |
| isWeekend = (>Fri) | |
| data Task = Work | Shop | Play deriving (Eq, Show) | |
| -- You are given a schedule, which is a list of pairs of Tasks and Days | |
| schedule :: [(Task, Day)] | |
| schedule = [(Shop, Fri), (Work, Tue), (Play, Mon), (Play, Fri)] | |
| -- However, the schedule is a mess | |
| -- Sort the schedule by Day, and return only a list of Tasks. | |
| -- If there are many Tasks in a Day, you should keep its original ordering | |
| -- For example, "sortTask schedule" should return "[(Play, Mon), (Work, Tue), (Shop, Fri), (Play, Fri)]" | |
| sortTask :: [(Task, Day)] -> [Task] | |
| sortTask = (map fst) . (sortOn snd) | |
| -- This function converts days to names, like "show", but a bit fancier | |
| -- For example, "nameOfDay Mon" should return "Monday" | |
| nameOfDay :: Day -> String | |
| nameOfDay = (["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"] !!) . fromEnum | |
| -- You shouldn't be working on the weekends | |
| -- Return "False" if the Task is "Work" and the Day is "Sat" or "Sun" | |
| labourCheck :: Task -> Day -> Bool | |
| labourCheck task day = not $ (task == Work) && (isWeekend day) | |
| -- Raise x to the power y using recursion | |
| -- For example, "power 3 4" should return "81" | |
| power :: Int -> Int -> Int | |
| power x y = if y == 0 then 1 else x * power x (y-1) | |
| -- Convert a list of booleans (big-endian) to a interger using recursion | |
| -- For example, "convertBinaryDigit [True, False, False]" | |
| convertBinaryDigit :: [Bool] -> Int | |
| convertBinaryDigit = foldl ((.fromEnum).(+).(*2)) 0 | |
| -- Create a fibbonaci sequence of length N in reverse order | |
| -- For example, "fib 5" should return "[3, 2, 1, 1, 0]" | |
| fib :: Int -> [Int] | |
| fib n = let f t = zipWith (+) (0:1:t) (0:t) in let x = f x in reverse $ take n x | |
| -- Determine whether a given list is a palindrome | |
| -- For example, "palindrome []" or "palindrome [1, 3, 1]" should return "True" | |
| palindrome :: Eq a => [a] -> Bool | |
| palindrome xs = xs == (reverse xs) | |
| -- Map the first component of a pair with the given function | |
| -- For example, "mapFirst (+3) (4, True)" should return "(7, True)" | |
| mapFirst :: (a -> b) -> (a, c) -> (b, c) | |
| mapFirst = (swap.).(.swap).fmap | |
| -- Devise a function that has the following type | |
| someFunction :: (a -> b -> c) -> (a -> b) -> a -> c | |
| someFunction f g x = f x (g x) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment