1

I'm trying to make a function that takes in a list, and if one of the elements is negative, then any elements in that list that are equal to its positive counterpart should be changed to 0. Eg, if there is a -2 in a list, then all 2's in that list should be changed to 0.

Any ideas why it only works for some cases and not others? I'm not understanding why this is, I've looked it over several times.

changeToZero [] = []
changeToZero [x] = [x]
changeToZero (x:zs:y:ws) | (x < 0) && ((-1)*(x) == y) = x : zs : 0 : changeToZero ws
changeToZero (x:xs) = x : changeToZero xs

changeToZero [-1,1,-2,2,-3,3]
-- [-1,1,-2,2,-3,3]

changeToZero [-2,1,2,3]
-- [-2,1,0,3]

changeToZero [-2,1,2,3,2]
-- [-2,1,0,3,2]

changeToZero [1,-2,2,2,1]
-- [1,-2,2,0,1]
Improve this question
3
  • 1
    The expression x:zs:y:ws is equivalent to [x,zs,y] ++ ws. Thus, zs will always be a single element of the list; it will never be multiple elements (or no elements). Commented Oct 6, 2012 at 21:44
  • If I wanted zs to be multiple elements, would x:zs:y make it be considered multiple, rather than a single element? Sorry, I'm trying to learn as much as I can, as I'm a beginner! Commented Oct 6, 2012 at 22:23
  • I'm afraid not. In the expression (or pattern) a:b, a is always a single element and b is always a list; the expression a:b is equivalent to [a] ++ b. As a consequence of the fact that : is right-associative, this means that in an expression (or pattern) such as a:b:c:d, the rightmost variable is "the rest of the list", and the other variables are individual elements. Commented Oct 7, 2012 at 3:20

3 Answers 3

Reset to default
7

I think a list comprehension is both clearer and easier to get right here.

changeToZero xs = [if x > 0 && (-x) `elem` xs then 0 else x | x <- xs]

If you need something more efficient, you can build a set of the negative elements and check that instead of using elem.

import qualified Data.Set as Set

changeToZero' xs = [if (-x) `Set.member` unwanted then 0 else x | x <- xs]
  where unwanted = Set.fromList $ filter (< 0) xs
Improve this answer
Sign up to request clarification or add additional context in comments.

2 Comments

Thank you! I didn't know that you could use list comprehension with an if/else clause. (I'm a beginner, as you can tell, lol) :)
The Set method here is noticably faster than O(n^2). Perhaps jdevelop was referring to the elem method. +1 for clarity.
2

you don't anctually remember which negative symbols you found in the list

import qualified Data.Set as S

changeToZero :: [Int] -> [Int]
changeToZero [] = []
changeToZero xs = reverse . snd $ foldl f (S.empty,[]) xs
  where
    f (negs,res) x | x < 0 = (S.insert (-x) negs, x:res)
                   | S.member x negs = (negs,0:res)
                   | otherwise = (negs,x:res)
Improve this answer

7 Comments

unnecessary complicated, see the elegant list comprehension based hammar's solution
it's still more efficient, because with list comprehension version list is evaluated 2 times. No reason to downvote still.
Thank you for your response! I prefer to only use Data.List, but this would work too! I've up-voted your answer :)
This will only work if the negative number appears before the positive counterpart.
I'm not sure it is what the OP wants in light of the first paragraph of the question. I admit the OP's code suggests subsequent values should be zero, but that might be by mistake.
|
2

Well, building on the answer from @jdevelop, if the negative has to appear before the positive in order to count, then you can build the result with a single pass over the input, without the need to reverse it:

import qualified Data.Set as S
import Control.Monad.State

changeToZero :: [Int] -> [Int]
changeToZero xs = evalState (mapM f xs) S.empty where
  f x | x < 0     = modify (S.insert (-x)) >> return x
      | otherwise = gets (S.member x) >>= \hasNeg -> return $ if hasNeg then 0 else x

In this way, you can get an answer to

take 4 $ changeToZero $ 1 : (-2) : 3 : 2 : undefined

where the other solutions will fail.

** Edit **

Here is the same thing, but without the State monad, which makes it easier to understand:

changeToZero' :: [Int] -> [Int]
changeToZero' = go S.empty where
  go _ [] = []
  go s (x:xs) | x < 0        = x : go (S.insert (-x) s) xs
              | S.member x s = 0 : go s xs
              | otherwise    = x : go s xs
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.