分开列表haskell的偶数和奇数元素

Question

I am trying to separate elements of a list into to further lists, one for the odd and one for even numbers.

For Example,

input: [1,2,3,4,10]
output: ([2,4,10],[1,3])

sepList :: [Int]->([Int],[Int])
sepList [] = ([],[])
sepList (x:xs) | (x mod 2) ==0 = (([x],[]) ++ sepList xs) 
               | (x mod 2) /=0 = (([],[x]) ++ sepList xs)
               | otherwise = ([],[])

It gives error on ...++ sepList xs anyone could guide me here?

Answer 1

The operator ++ is used to concatenate 2 lists and neither of your arguments to ++ is a list,

([x],[]) ++ sepList xs

both ([x],[]) and sepList xs are pairs of lists. So what you want is to pattern match on sepList xs eg using a let binding,

let (ys,zs) = sepList xs in

and then return,

(x:ys,zs)

Answer 2

You aren't concatenating two lists; you want to add a single element to a list, selected from the tuple output of the recursive call. Don't use (++) ; use (:) .

sepList (x:xs) = let (evens, odds) = sepList xs
                 in if even x 
                    then (x:evens, odds)
                    else (evens, x:odds)

More simply, though, sepList = partition even . ( partition can be found in Data.List .)

Answer 3

There are two answers so far which suggest basically doing this by hand (by pattern-matching on the result of the recursive call), but there is actually an operator already defined for the types that you're working with that does exactly what you want! Lists form a monoid with (<>) = (++) , but you don't have two lists: you have two pairs of lists. Happily, the type of pairs are also a monoid if each element of the pair is a monoid: (a,b) <> (c,d) = (a <> c, b <> d) . So, you can simply replace your ++ call with <> , which will result in concatenating the corresponding lists in your pairs.

Answer 4

对于发烧友来说，遵循一行也可以将偶数和奇数分开。

sepList xs = (filter even xs , filter odd xs)

Answer 5

  import Data.List

  sepList :: [Int]->([Int],[Int])
  sepList = partition even

  sepList [1,2,3,4,10]

Answer 6

In this case i would use an accumulator to create the tuple containing the two lists.In our case the accumulator is ([],[]) .

split::[Int]->([Int],[Int])
split ls= go  ([],[]) ls where 
   go accu [] = accu
   go (odd,even) (x:xs) | x `mod` 2==0 = go (x:odd,even) xs
                        | otherwise = go (odd, x:even) xs

As you can see the elements need to be reversed since we are pushing on top of our lists with the : operator.

I do not know if this is optimal but i would write it like this with reverse :

module Split where
split::[Int]->([Int],[Int])
split ls=let rev tupl=(reverse . fst $ tupl ,reverse .snd $ tupl) in 
             rev $  go ([],[]) ls where 
                    go accu [] = accu
                    go (odd,even) (x:xs) | x `mod` 2==0 = go (x:odd,even) xs
                                         | otherwise = go (odd, x:even) xs