Difference between revisions of "99 questions/Solutions/18"
< 99 questions | Solutions
Jump to navigation
Jump to search
(added a cleaner version of the final solution) |
|||
Line 52: | Line 52: | ||
<haskell> |
<haskell> |
||
slice xs (i+1) k = snd (split (fst (split xs k)) i) |
slice xs (i+1) k = snd (split (fst (split xs k)) i) |
||
+ | </haskell> |
||
+ | |||
+ | A solution using <hask>zip</hask>, <hask>filter</hask> then <hask>map</hask> seems straight-forward to me |
||
+ | |||
+ | <haskell> |
||
+ | slice xs i j = map snd |
||
+ | $ filter (\(x,_) -> x >= i && x <= j) |
||
+ | $ zip [1..] xs |
||
</haskell> |
</haskell> |
Revision as of 06:27, 20 November 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
A little cleaner, using the previous problem's split (a.k.a. splitAt
):
slice xs (i+1) k = snd (split (fst (split xs k)) i)
A solution using zip
, filter
then map
seems straight-forward to me
slice xs i j = map snd
$ filter (\(x,_) -> x >= i && x <= j)
$ zip [1..] xs