# 99 questions/Solutions/20

### From HaskellWiki

< 99 questions | Solutions(Difference between revisions)

(Added another solution that also indicates failure using Maybe (thanks to zygoloid from #haskell for the input regarding Maybe)) |
(Added another solution) |
||

Line 37: | Line 37: | ||

| otherwise = (Just (xs !! nr), fst splitted ++ (tail . snd) splitted) | | otherwise = (Just (xs !! nr), fst splitted ++ (tail . snd) splitted) | ||

where splitted = splitAt nr xs | where splitted = splitAt nr xs | ||

+ | </haskell> | ||

+ | |||

+ | And yet another solution (without error checking): | ||

+ | |||

+ | <haskell> | ||

+ | removeAt :: Int -> [a] -> (a, [a]) | ||

+ | removeAt n xs = let (front, back) = splitAt n xs in (last front, init front ++ back) | ||

</haskell> | </haskell> |

## Revision as of 07:30, 12 August 2011

(*) Remove the K'th element from a list.

removeAt :: Int -> [a] -> (a, [a]) removeAt k xs = case back of [] -> error "removeAt: index too large" x:rest -> (x, front ++ rest) where (front, back) = splitAt k xs

splitAt

If the original list has fewer than k+1 elements, the second list will be empty, and there will be no element to extract. Note that the Prolog and Lisp versions treat 1 as the first element in the list, and the Lisp version appends NIL elements to the end of the list if k is greater than the list length.

or

removeAt n xs = (xs!!n,take n xs ++ drop (n+1) xs)

Another solution that avoids throwing an error and using ++ operators. Treats 1 as the first element in the list.

removeAt :: Int -> [a] -> (Maybe a, [a]) removeAt _ [] = (Nothing, []) removeAt 1 (x:xs) = (Just x, xs) removeAt k (x:xs) = let (a, r) = removeAt (k - 1) xs in (a, x:r)

Another solution that also uses Maybe to indicate failure:

removeAt :: Int -> [a] -> (Maybe a, [a]) removeAt _ [] = (Nothing, []) removeAt 0 xs = (Nothing, xs) removeAt nr xs | nr > length xs = (Nothing, xs) | otherwise = (Just (xs !! nr), fst splitted ++ (tail . snd) splitted) where splitted = splitAt nr xs

And yet another solution (without error checking):

removeAt :: Int -> [a] -> (a, [a]) removeAt n xs = let (front, back) = splitAt n xs in (last front, init front ++ back)