Write a function that replaces the character c to '*'-CodePudding

Condition: Function containing character c and string xs, where all c's are replaced by '*'.

zensiert :: [Char] -> String
zensiert c (x:xs) 
    | x == c = x == '*'
    | otherwise = zensiert c (x:xs)

` The map function and list generators are prohibited. Example: zensiert 'l' ''Rolls a ball around the corner and falls down.'' returns:''Ros a ba around the corner and fas down.''

Because of the example is was thinking that is at the beginning a list in a char that leads to a string, but it didn ´ t work. Because of that I would be very conceivable, if someone would look over there times

Now I tried so:

zensiert :: [Char] -> String                               
zensiert (x:xs) = if x == 'c' then ('*' : zensiert xs) else (x : zensiert xs)

But there is the problem, if i give zensiert 'l' "Hello", the terminal says: Couldn't match expected type ‘[Char] -> t’ with actual type ‘[Char]’

CodePudding user response：

First, the type signature should be

zensiert :: Char -> String -> String

You'll take a character and a string as arguments, and return a new string.

== is not an assignment operator, even if Haskell did have assignments. Your second definition would be fine (for replacing hard-coded 'c's, anyway), except you don't define it for the empty string the recursive call will eventually receive, and you incorrectly call it with a Char argument it won't use.

The correct definition takes a Char argument and uses that instead of the Char literal 'c'.

zensiert :: Char -> String -> String
zensiert _ [] = []
zensiert c (x:xs) = if x == c then ('*' : zensiert xs) else (x : zensiert xs)

A simpler approach would be to use map to apply a function that replaces 'c' with '*' to a list, whether it is empty or not.

zensiert c xs = map (\x -> if x == c then '*' else x) xs

zensiert c xs = map f xs
    where f 'c' = '*'
          f x = x

CodePudding user response：

Whenever you are defining recursive functions, you need at least one base case that exists the recursion, and at least one case that calls the function recursively in a way that converges on the base case.

If you're dealing with strings, the base case is often an empty string, and we converge the making the input string closer to an empty string.

Replacing any character with '*' in an empty string gives us just an empty string, so the base case is simple. For the update case, we just have to decide what to append to recursively calling the function on the "tail" of the string.

ghci> :{
ghci| subChar _ "" = ""
ghci| subChar c (x:xs) 
ghci|   | c == x    = '*' : subChar c xs
ghci|   | otherwise =  x  : subChar c xs
ghci| :}
ghci> subChar 'l' "world"
"wor*d"
ghci>