Personal tools

99 questions/Solutions/18

From HaskellWiki

< 99 questions | Solutions(Difference between revisions)
Jump to: navigation, search
(I've come up with a solution that actually is an extended version of the 1st solution)
m (Updated my solution to a more paranoid one)
Line 7: Line 7:
 
</haskell>
 
</haskell>
   
The same solution as above, but with guards:
+
The same solution as above, but the more paranoid (maybe too paranoid?) version of it (uses guards and Maybe):
   
 
<haskell>
 
<haskell>
slice [] _ _ = []
+
slice :: [a] -> Int -> Int -> Maybe [a]
slice xs k n | k == n = []
+
slice [] _ _ = Just []
| k > n = error "k > n"
+
slice xs k n | k == n = Just []
| k == 0 = take n xs
+
| k > n || k > length xs || n > length xs || k < 0 || n < 0 = Nothing
| otherwise = drop (k-1) $ take n xs
+
| k == 0 = Just (take n xs)
  +
| otherwise = Just (drop (k-1) $ take n xs)
 
</haskell>
 
</haskell>
   

Revision as of 15:59, 18 August 2010

(**) Extract a slice from a list.

Given two indices, i and k, the slice is the list containing the elements between the i'th and k'th element of the original list (both limits included). Start counting the elements with 1.

slice xs (i+1) k = take (k-i) $ drop i xs

The same solution as above, but the more paranoid (maybe too paranoid?) version of it (uses guards and Maybe):

slice :: [a] -> Int -> Int -> Maybe [a]
slice [] _ _ = Just []
slice xs k n 	| k == n = Just []
		| k > n || k > length xs || n > length xs || k < 0 || n < 0 = Nothing
		| k == 0 = Just (take n xs)
		| otherwise = Just (drop (k-1) $ take n xs)

Or, an iterative solution:

slice :: [a]->Int->Int->[a]
slice lst 1 m = slice' lst m []
        where
                slice' :: [a]->Int->[a]->[a]
                slice' _ 0 acc = reverse acc
                slice' (x:xs) n acc = slice' xs (n - 1) (x:acc)
slice (x:xs) n m = slice xs (n - 1) (m - 1)

Or:

slice :: [a] -> Int -> Int -> [a]
slice (x:xs) i k
 | i > 1	= slice xs (i - 1) (k - 1)
 | k < 1	= []
 | otherwise	= x:slice xs (i - 1) (k - 1)
Another way using
splitAt
, though not nearly as elegant as the
take
and
drop
version:
slice :: [a] -> Int -> Int -> [a]
slice xs i k = chunk
  where chop  = snd $ splitAt i' xs          -- Get the piece starting at i
        chunk = fst $ splitAt (k - i') chop  -- Remove the part after k
        i'    = i - 1