429 lines
11 KiB
Haskell
429 lines
11 KiB
Haskell
--DO NOT MODIFY--
|
|
module SolutionPA2 where
|
|
import Prelude hiding (mod,double,square,sum,reverse)
|
|
|
|
-- command to run the test:
|
|
-- ghc /home/cs/cs420/autograder/PA2/Test.hs -e main
|
|
|
|
-- colored printing enabled
|
|
coloredPrint = True
|
|
--DO NOT MODIFY--
|
|
|
|
--Write your solution below--
|
|
--Write your solutions after Function Type, the sentence after that is just a placeholder
|
|
|
|
-- Part A: Basic Haskell Prelude
|
|
-- In this part of the assignment you will create your own prelude libraries
|
|
|
|
--myMod
|
|
--Write your own modulus function that is calculate the remainder
|
|
--
|
|
-- myMod 12 4
|
|
-- >>> 0
|
|
--
|
|
-- myMod 12 5
|
|
-- >>> 2
|
|
--
|
|
-- myMod 12 12
|
|
-- >>> 0
|
|
|
|
myMod :: Int -> Int -> Int
|
|
-- Idea: Use integer division, multiply back out, and find the
|
|
-- difference.
|
|
myMod x y = x - (y * div x y)
|
|
|
|
|
|
--toDigit
|
|
--The function is to convert a positive number to a list of number, if it is negative or 0 then return empty list
|
|
--
|
|
-- toDigit 13
|
|
-- >>> [1,3]
|
|
--
|
|
-- toDigit 0
|
|
-- >>> []
|
|
--
|
|
-- toDigit (-13)
|
|
-- >>> []
|
|
|
|
toDigit :: Int -> [Int]
|
|
toDigit n | n <= 0 = []
|
|
-- Resursive step.
|
|
-- Call toDigit with the number divided by 10, and append that
|
|
-- to the list with just the last digit (mod)
|
|
| otherwise = toDigit (div n 10) ++ [myMod n 10]
|
|
|
|
|
|
--reverseList (10 pts)
|
|
--The function is used to reverse a list of arbitrary type
|
|
-- reverseList ['a','b','c']
|
|
-- >>> "cba"
|
|
-- reverseList [1,2,3,4]
|
|
-- >>> [4,3,2,1]
|
|
-- reverseList "racecar"
|
|
-- >>> "racecar"
|
|
|
|
reverseList :: [a] -> [a]
|
|
-- Base case.
|
|
reverseList [] = []
|
|
-- Recursive step, use pattern matching to get last part of list,
|
|
-- reverse it, and then append the first element at the end.
|
|
reverseList (x:xs) = reverseList xs ++ [x]
|
|
|
|
--sumList
|
|
--The function is used to get the sum of a list of number
|
|
-- sumList [1,2,3,4]
|
|
-- >>> 10
|
|
--
|
|
-- sumList [1,2,3,(-2)]
|
|
-- >>> 4
|
|
--
|
|
-- sumList []
|
|
-- >>> 0
|
|
|
|
sumList :: [Int] -> Int
|
|
-- Base case.
|
|
sumList [] = 0
|
|
-- Recursive step, use pattern matching to split list into first
|
|
-- element, and add it to the sum of everything else.
|
|
sumList (x:xs) = sumList xs + x
|
|
|
|
|
|
|
|
--toDigitRev is used to reverse toDigit list
|
|
--
|
|
-- toDigitRev 34
|
|
-- >>> [4,3]
|
|
--
|
|
-- toDigitRev 53
|
|
-- >>> [3,5]
|
|
--
|
|
-- toDigitRev 10
|
|
-- >>> [0,1]
|
|
|
|
toDigitRev :: Int -> [Int]
|
|
-- Just use reverseList and toDigit.
|
|
toDigitRev n = reverseList (toDigit n)
|
|
|
|
-- Part B: Folding Function
|
|
-- In this part of the problems, you have to use foldr. Every function will be check for the foldr unless specified otherwise such as doubleEveryOther
|
|
-- Without using foldr, your function will be mark 0 even if the output is correct
|
|
|
|
--myDouble
|
|
--Write your own double function that is using foldr
|
|
--without using fold it will be 0 even the output is right
|
|
--
|
|
-- myDouble 2
|
|
-- >>> 4
|
|
--
|
|
-- myDouble 4
|
|
-- >>> 8
|
|
--
|
|
-- myDouble 0
|
|
-- >>> 0
|
|
|
|
myDouble :: Int -> Int
|
|
-- We can sum the list of 2 of the parameter.
|
|
myDouble n = foldr (+) 0 [n,n]
|
|
|
|
|
|
-- doubleEveryOther will double the value of every other digit from left to right, beginning with the second digit
|
|
-- NOTE: You do not have to use foldr for this particular function.
|
|
--
|
|
-- doubleEveryOther [1,2,3,4]
|
|
-- >>> [1,4,3,8]
|
|
--
|
|
-- doubleEveryOther [1,2,3]
|
|
-- >>> [1,4,3]
|
|
|
|
doubleEveryOther :: [Int] -> [Int]
|
|
-- I don't like this code. It doesn't feel very Haskell.
|
|
-- Use list comprehension to get all the indices of xs.
|
|
-- Then if the index is odd, double the value.
|
|
-- This will double every other starting with the 2nd digit.
|
|
doubleEveryOther xs = [if myMod i 2 == 0 then xs !! i else myDouble (xs!!i) | i <- [0..(length xs) - 1]]
|
|
|
|
--mySquare
|
|
--Write your own my square function using foldr
|
|
--
|
|
-- mySquare 0
|
|
-- >>> 0
|
|
--
|
|
-- mySquare 1
|
|
-- >>> 1
|
|
--
|
|
-- mySquare (-5)
|
|
-- >>> 25
|
|
|
|
mySquare :: Int -> Int
|
|
-- Use foldr with a list of [n,n] and *.
|
|
mySquare n = foldr (*) 1 [n,n]
|
|
|
|
|
|
-- Write sqSum function such that sqSum [x1, ... , xn] should return (x1^2 + ... + xn^2)
|
|
--
|
|
-- >>> sqSum []
|
|
-- 0
|
|
--
|
|
-- >>> sqSum [1,2,3,4]
|
|
-- 30
|
|
--
|
|
-- >>> sqSum [(-1), (-2), (-3), (-4)]
|
|
-- 30
|
|
|
|
sqSum :: [Int] -> Int
|
|
-- We can use foldr and list comprehension to add evertything in a new
|
|
-- list where mySquare was applied (map).
|
|
sqSum ns = foldr (+) 0 [mySquare x | x <- ns]
|
|
|
|
|
|
--sumDigits is to add the sum of all the number inside the list that is already turn into single digit (10 pts)
|
|
--
|
|
-- sumDigits [1,10,12] which is 1 + 1 + 0 + 1 + 2
|
|
-- >>> 5
|
|
--
|
|
-- sumDigits [23,32,(-45)] which is 2 + 3 + 3 + 2 + 0
|
|
-- >>> 10
|
|
|
|
sumDigits :: [Int] -> Int
|
|
-- We can use a double list comprehension combined with foldr.
|
|
-- Take every n from ns.
|
|
-- Find the digits, and then get every digit x.
|
|
-- Combine it all into a list and apply foldr.
|
|
sumDigits ns = foldr (+) 0 [x | n <- ns, x <- toDigit n]
|
|
|
|
-- sepConcat will concatenate the defined seperator to a list of string. If the list is empty despite the defined seperator return empty string.
|
|
--
|
|
-- sepConcat ", " []
|
|
-- >>> ""
|
|
--
|
|
-- sepConcat ", " ["foo", "bar", "baz"]
|
|
-- >>> "foo, bar, baz"
|
|
--
|
|
-- sepConcat "#" ["a","b","c","d","e"]
|
|
-- >>> "a#b#c#d#e"
|
|
|
|
sepConcat :: String -> [String] -> String
|
|
-- Base case 1, when the list is empty.
|
|
sepConcat _ [] = []
|
|
-- Pattern match a list with only one element.
|
|
-- When we reach this case, we don't add separator to the end.
|
|
sepConcat _ (t:[]) = t
|
|
-- On the recursive case, we patten match the first element and the rest
|
|
-- of the list. We then concat it with the separator and recurse.
|
|
sepConcat sep (t:ts) = t ++ sep ++ sepConcat sep ts
|
|
|
|
|
|
-- Part C: Credit Card problem
|
|
|
|
-- Using the above written functions, create a validate function will decide if a number is legal to use as credit card using Luhn algorithm
|
|
-- Luhn algorithm:
|
|
-- 1) Double the value of every other digit from right to left, beginning with the second to last digit.
|
|
-- 2) Add the digits of the results of Step 1 to the remaining digits in the credit card number.
|
|
-- 3) If the result mod 10 is equal to 0, the number is valid. If the result mod 10 is not equal to 0, the validation fails.
|
|
-- source: https://www.ibm.com/docs/en/order-management-sw/9.3.0?topic=cpms-handling-credit-cards
|
|
--To validate the credit card using this website
|
|
--https://dnschecker.org/credit-card-validator.php
|
|
--To generate using same website above or this
|
|
--https://www.lambdatest.com/free-online-tools/credit-card-number-generator
|
|
|
|
--
|
|
-- validate 4723304884813
|
|
-- >>> True
|
|
--
|
|
-- validate 4012888888881881
|
|
-- >>> True
|
|
--
|
|
-- validate 4012888888881882
|
|
-- >>> False
|
|
|
|
validate :: Int -> Bool
|
|
-- Application of all our functions.
|
|
validate n = myMod (sumDigits (doubleEveryOther (toDigitRev n))) 10 == 0
|
|
|
|
|
|
-- PartD: Sorts algorithms
|
|
|
|
-- splitHalf will split a list of number to 2 half
|
|
--
|
|
-- splitHalf [1,2,3,4,5]
|
|
-- >>> ([1,2],[3,4,5])
|
|
--
|
|
-- splitHalf [1,2,3,4,5,6]
|
|
-- >>> ([1,2,3],[4,5,6])
|
|
|
|
-- helper function
|
|
-- Base case.
|
|
mySplit 0 p = p
|
|
-- mySplit will collect from the 2nd ordered pair, and move n
|
|
-- elements into the first list.
|
|
-- This is done recursively by decrementing n on each call, and moving
|
|
-- one y into left of the ordered pair.
|
|
mySplit n (xs,(y:ys)) = mySplit (n-1) (xs++[y], ys)
|
|
|
|
splitHalf :: [a] -> ([a], [a])
|
|
-- splitHalf simply calls mySplit with n = length / 2.
|
|
splitHalf xs = mySplit (div l 2) ([], xs)
|
|
where l = length xs
|
|
|
|
|
|
-- mergeList will merge 2 list that is sorted by the key value b
|
|
--
|
|
-- mergeList [("dat",1),("scott",5)] [("dan",3),("scott",4)]
|
|
-- >>> [("dat",1),("dan",3),("scott",4),("scott",5)]
|
|
--
|
|
-- mergeList [("danny",35),("scott",5)] [("dan",3),("scott",4)]
|
|
-- >>> [("dan",3),("scott",4),("danny",35),("scott",5)]
|
|
|
|
|
|
mergeList :: Ord b => [(a, b)] -> [(a, b)] -> [(a, b)]
|
|
-- Base case.
|
|
-- If one of the lists is empty, then we can just return one of the
|
|
-- lists.
|
|
mergeList [] pys = pys
|
|
mergeList pxs [] = pxs
|
|
|
|
-- Lots of pattern matching.
|
|
-- axs, ays = "All xs"
|
|
-- x,y = Sorting value
|
|
-- ys,xs = "Rest of xs"
|
|
mergeList axs@( px@(_,x) : xs) ays@( py@(_,y) : ys)
|
|
-- If x <= y, the first pair ps should go first.
|
|
-- Then we can merge the rest of xs with all of ays.
|
|
| x <= y = px : mergeList xs ays
|
|
-- Otherwise, we can just call mergeList again.
|
|
| otherwise = py : mergeList axs ys
|
|
|
|
|
|
-- mergeSort will sort using mergeList function
|
|
--
|
|
-- mergeSort [("dat",1),("scott",5),("Tim",2)]
|
|
-- >>> [("dat",1),("Tim",2),("scott",5)]
|
|
--
|
|
-- mergeSort [("dat",1),("dan",5),("scott",4),("scottish",3)]
|
|
-- >>> [("dat",1),("dat2",3),("scott",4),("scott",5)]
|
|
|
|
-- Some helper function
|
|
-- Apply a function that takes 2 params and apply it to an ordered pair
|
|
-- with the 2 parameters.
|
|
applyPair :: (a->b->c) -> (a,b) -> c
|
|
applyPair f (x,y) = f x y
|
|
|
|
-- Apply a function to each part of the pair.
|
|
applyEachPair :: (a->b) -> (a,a) -> (b,b)
|
|
applyEachPair f (x, y) = (f x, f y)
|
|
|
|
mergeSort :: Ord b => [(a,b)] -> [(a,b)]
|
|
-- Base cases
|
|
mergeSort [] = []
|
|
mergeSort [x] = [x]
|
|
|
|
-- To merge a list xs,
|
|
-- we split the list in half, and recursive apply mergeSort to each
|
|
-- half.
|
|
-- Then, we mergeList on both of them.
|
|
mergeSort xs = applyPair mergeList (applyEachPair mergeSort (splitHalf xs))
|
|
|
|
|
|
-- Part E - working with new type
|
|
-- Note: You should not use fold anywhere in this part of the assignment
|
|
type BigInt = [Int]
|
|
--
|
|
-- You will be writing three helper functions to solve bigAdd, mulByDigit, bigMul
|
|
|
|
-- `clone x n` returns a `[x,x,...,x]` containing `n` copies of `x`
|
|
--
|
|
-- clone 3 5
|
|
-- >>> [3,3,3,3,3]
|
|
--
|
|
-- clone "foo" 2
|
|
-- >>> ["foo", "foo"]
|
|
|
|
clone :: a -> Int -> [a]
|
|
-- Base case
|
|
clone _ 0 = []
|
|
-- List with just x
|
|
clone x 1 = x : []
|
|
-- Create a list with [x], then recursive call function.
|
|
clone x n = x : clone x (n-1)
|
|
|
|
|
|
-- `padZero l1 l2` returns a pair (l1', l2') which are the input lists,
|
|
-- padded with extra `0` on the left such that the lengths of `l1'`
|
|
-- and `l2'` are equal.
|
|
--
|
|
-- padZero [9,9] [1,0,0,2]
|
|
-- >>> ([0,0,9,9], [1,0,0,2])
|
|
--
|
|
-- padZero [1,0,0,2] [9,9]
|
|
-- >>> ([1,0,0,2], [0,0,9,9])
|
|
|
|
-- Helper function
|
|
clonez = clone 0
|
|
|
|
padZero :: BigInt -> BigInt -> (BigInt, BigInt)
|
|
-- If left is longer, clone zeros and prepend to right.
|
|
-- If right is longer, clone zeros and prepend to left.
|
|
-- Otherwise, if they're the same, just return them.
|
|
padZero xs ys | xl > yl = (xs, clonez (xl-yl) ++ ys)
|
|
| xl < yl = (clonez (yl-xl) ++ xs, ys)
|
|
| otherwise = (xs,ys)
|
|
where xl = length xs
|
|
yl = length ys
|
|
|
|
|
|
-- `removeZero ls` strips out all leading `0` from the left-side of `ls`.
|
|
--
|
|
-- removeZero [0,0,0,1,0,0,2]
|
|
-- >>> [1,0,0,2]
|
|
--
|
|
-- removeZero [9,9]
|
|
-- >>> [9,9]
|
|
--
|
|
-- removeZero [0,0,0,0]
|
|
-- >>> []
|
|
|
|
removeZero :: BigInt -> BigInt
|
|
-- Base case
|
|
removeZero [] = []
|
|
-- If we can pattern match a zero, recurse with rest of list.
|
|
removeZero (0:xs) = removeZero xs
|
|
-- Otherwise just return it.
|
|
removeZero xs = xs
|
|
|
|
|
|
-- `bigAdd n1 n2` returns the `BigInt` representing the sum of `n1` and `n2`
|
|
--
|
|
-- bigAdd [9, 9] [1, 0, 0, 2]
|
|
-- >>> [1, 1, 0, 1]
|
|
--
|
|
-- bigAdd [9, 9, 9, 9] [9, 9, 9]
|
|
-- >>> [1, 0, 9, 9, 8]
|
|
|
|
--bigAdd :: BigInt -> BigInt -> BigInt
|
|
bigAdd _ _ = "not implemented"
|
|
|
|
|
|
-- `mulByDigit i n` returns the result of multiplying
|
|
-- the digit `i` (between 0..9) with `BigInt` `n`.
|
|
--
|
|
-- mulByDigit 9 [9,9,9,9]
|
|
-- >>> [8,9,9,9,1]
|
|
|
|
--mulByDigit :: Int -> BigInt -> BigInt
|
|
mulByDigit _ _ = "not implemented"
|
|
|
|
|
|
-- `bigMul n1 n2` returns the `BigInt` representing the
|
|
-- product of `n1` and `n2`.
|
|
--
|
|
-- bigMul [9,9,9,9] [9,9,9,9]
|
|
-- >>> [9,9,9,8,0,0,0,1]
|
|
--
|
|
-- bigMul [9,9,9,9,9] [9,9,9,9,9]
|
|
-- >>> [9,9,9,9,8,0,0,0,0,1]
|
|
|
|
--bigMul :: BigInt -> BigInt -> BigInt
|
|
bigMul _ _ = "not implemented"
|
|
|
|
|