Difference between revisions of "99 questions/Solutions/9"

From HaskellWiki
Jump to: navigation, search
(Undo revision 39658 by Tyr (Talk))
(code long line breakup)
Line 9: Line 9:
 
</haskell>
 
</haskell>
   
This is implemented as <hask>group</hask> in <hask>Data.List</hask>.
+
This is implemented as <hask>group</hask>&nbsp;in <hask>Data.List</hask>.
   
 
A more verbose solution is
 
A more verbose solution is
Line 25: Line 25:
 
</haskell>
 
</haskell>
   
Similarly, using <hask>splitAt</hask> and <hask>findIndex</hask>:
+
Similarly, using <hask>splitAt</hask>&nbsp;and <hask>findIndex</hask>:
   
 
<haskell>
 
<haskell>
Line 32: Line 32:
 
pack (x:xs) = (x:reps) : (pack rest)
 
pack (x:xs) = (x:reps) : (pack rest)
 
where
 
where
(reps, rest) = maybe (xs,[]) (\i -> splitAt i xs) (findIndex (/=x) xs)
+
(reps, rest) = maybe (xs,[]) (\i -> splitAt i xs)
  +
(findIndex (/=x) xs)
 
</haskell>
 
</haskell>
   
Another solution using <hask>takeWhile</hask> and <hask>dropWhile</hask>:
+
Another solution using <hask>takeWhile</hask>&nbsp;and <hask>dropWhile</hask>:
   
 
<haskell>
 
<haskell>
Line 43: Line 43:
 
</haskell>
 
</haskell>
   
Or we can use <hask>foldr</hask> to implement this:
+
Or we can use <hask>foldr</hask>&nbsp;to implement this:
   
 
<haskell>
 
<haskell>

Revision as of 09:53, 1 June 2011

(**) Pack consecutive duplicates of list elements into sublists.

If a list contains repeated elements they should be placed in separate sublists.

pack (x:xs) = let (first,rest) = span (==x) xs
               in (x:first) : pack rest
pack [] = []

This is implemented as group in Data.List.

A more verbose solution is

pack :: Eq a => [a] -> [[a]]
pack [] = []
pack (x:xs) = (x:first) : pack rest
         where
           getReps [] = ([], [])
           getReps (y:ys)
                   | y == x = let (f,r) = getReps ys in (y:f, r)
                   | otherwise = ([], (y:ys))
           (first,rest) = getReps xs

Similarly, using splitAt and findIndex:

pack :: Eq a => [a] -> [[a]]
pack [] = []
pack (x:xs) = (x:reps) : (pack rest)
    where
        (reps, rest) = maybe (xs,[]) (\i -> splitAt i xs)
                         (findIndex (/=x) xs)

Another solution using takeWhile and dropWhile:

pack :: (Eq a) => [a] -> [[a]]
pack [] = []
pack (x:xs) = (x : takeWhile (==x) xs) : pack (dropWhile (==x) xs)

Or we can use foldr to implement this:

pack :: (Eq a) => [a] -> [[a]]
pack = foldr func []
    where func x []     = [[x]]
          func x (y:xs) =
              if x == (head y) then ((x:y):xs) else ([x]:y:xs)

A simple solution:

pack :: (Eq a) => [a] -> [[a]]
pack [] = []
pack [x] = [[x]]
pack (x:xs) = if x `elem` (head (pack xs)) 
              then (x:(head (pack xs))):(tail (pack xs))
              else [x]:(pack xs)