Call us +96895672917 | +917736882141

    Project Description

    haskell-logo

    Best Haskell Online Programming assignment help . Available  online 24/7 . Please send us an email with the requirement  for the quote. Well commented codes.

    a) Writing polymorphic functions
    Write a polymorphic function that accepts two lists, if the second list is a substring of the first then it should
    return the index of the substring and its length. If it is not a substring then it should return     (-1,-1). Some
    expected output from this function is shown below:
    Main> substring [1,4,6,2,4,6,7,2,3] [4,6,7]
    (4, 3)
    Main> substring “abbacdaacdcfa” “acdc”
    (7, 4)
    Main> substring [(1,5),(2,4),(6,6),(9,7)] [(2,4),(9,7)]
    (-1, -1)
    b) Writing a higher-order function
    Write a higher-order function that accepts a function and two lists. The higher-order function should return true
    if the given function returns true for every pair of elements in the second list and some substring of the first list.
    For example:
    Main> hsubstring (<) [4,1,2,5,2,4,4] [2,3,6]
    (1, 3)
    Main> hsubstring (<) [4,1,2,5,2,4,4] [2,3,1]
    (-1, -1)
    c) Using higher-order functions
    Write a higher-order function that accepts a function and three lists. The higher-order should determine if the
    second list is a substring of the first. If it is then it should remove it and replace it with the third list, if it is not
    then it should return the original list unchanged. Note that the third list may not be the same length.
    Main> replace (==) [4,1,2,5,2,4,4] [2,5,2] [4,2,1]
    [4,1,4,2,1,4,4]
    Main> replace (==) “Hello World!” “World” “159.202 Class”
    “Hello 159.202 Class!”
    d) Using lambda functions & functional-level definitions
    Define a function that can replace substrings in a sentence regardless of whether they are uppercase or lower
    case. You should use only a lambda function, a functional-level definition and your previous functions.
    Main> replaceString “To be, or not to be, that is the question” “QUESTION” “end”
    “To be, or not to be, that is the end”
    You must put the following comments at the top of your program code and provide the appropriate information.
    — Assignment number, 159.202, 2016 S5
    — Family Name, Given Name, Student ID,
    — Explain what the program is doing . . .
    Hand-in: Submit your script electronically through stream

     

    –Required for ‘toUpper’
    import Data.Char

    –a)
    substring :: (Eq a) => [a] -> [a] -> (Int, Int)
    substring x y = substring’ x y 0

    — susbstring’: auxiliar function that does the substring but has an extra parameter to count the index of the found substring
    — checkEqual a b: checks if all elements from list a are equal to all elements from list b
    substring’ [] _ _ = (-1,-1)
    substring’ (x:xs) (y:ys) c | x==y && checkEqual xs ys = (c, 1 + length ys)
    | otherwise = substring’ xs (y:ys) (c+1)
    where
    checkEqual _ [] = True
    checkEqual (x:xs) (y:ys) | x==y = checkEqual xs ys
    | otherwise = False

    ——————————————————————–
    –b)

    hsubstring :: (a->a->Bool) -> [a] -> [a] -> (Int, Int)
    hsubstring f x y = hsubstring’ f x y 0

    — hsubstring’: auxiliar function that does the hsubstring, but has an extra parametrer to count the index of the found substring
    — checkFunction f a b: checks if f x y is true for elements x from a and y from b
    hsubstring’ _ [] _ _ = (-1, -1)
    hsubstring’ f (x:xs) (y:ys) c | f x y && checkFunction f xs ys = (c, 1 + length ys)
    | otherwise = hsubstring’ f xs (y:ys) (c + 1)
    where
    checkFunction _ _ [] = True
    checkFunction f (x:xs) (y:ys) | f x y = checkFunction f xs ys
    | otherwise = False
    ——————————————————————–
    –c)
    replace :: (a->a->Bool) -> [a] -> [a] -> [a] -> [a]
    replace f a b c | index > -1 = (take index a) ++ c ++ (drop (index+l) a)
    | otherwise = a
    where
    (index, l) = hsubstring f a b

    ——————————————————————–
    –d)
    replaceString :: [Char] -> [Char] -> [Char] -> [Char]
    replaceString a b c = replace (\x y->toUpper x == toUpper y) a b c

     

    Project Details

    • Date November 3, 2016
    • Tags Haskell Programming, Programming

    Leave a reply

    Trustpilot