Given a Haskell list, return all sub-lists obtained by removing one element
up vote
9
down vote
favorite
I am trying to write a Haskell function which takes a list ls
and returns all sub-lists obtained by removing one element from ls
. An additional constraint is that the returned list of lists must be in the order of the missing element.
Here is what I have. I know there must be a simpler solution.
subOneLists :: [a] -> [[a]]
subOneLists ls = let helper :: [a] -> [a] -> [[a]] -> [[a]]
helper _ ss = ss
helper ps (x:xs) ss = helper ps' xs ss'
where ps' = ps ++ [x]
ss' = ss ++ [ps ++ xs]
in helper ls
λ> subOneLists [1, 2, 3, 4]
[[2,3,4],[1,3,4],[1,2,4],[1,2,3]]
haskell
New contributor
add a comment |
up vote
9
down vote
favorite
I am trying to write a Haskell function which takes a list ls
and returns all sub-lists obtained by removing one element from ls
. An additional constraint is that the returned list of lists must be in the order of the missing element.
Here is what I have. I know there must be a simpler solution.
subOneLists :: [a] -> [[a]]
subOneLists ls = let helper :: [a] -> [a] -> [[a]] -> [[a]]
helper _ ss = ss
helper ps (x:xs) ss = helper ps' xs ss'
where ps' = ps ++ [x]
ss' = ss ++ [ps ++ xs]
in helper ls
λ> subOneLists [1, 2, 3, 4]
[[2,3,4],[1,3,4],[1,2,4],[1,2,3]]
haskell
New contributor
add a comment |
up vote
9
down vote
favorite
up vote
9
down vote
favorite
I am trying to write a Haskell function which takes a list ls
and returns all sub-lists obtained by removing one element from ls
. An additional constraint is that the returned list of lists must be in the order of the missing element.
Here is what I have. I know there must be a simpler solution.
subOneLists :: [a] -> [[a]]
subOneLists ls = let helper :: [a] -> [a] -> [[a]] -> [[a]]
helper _ ss = ss
helper ps (x:xs) ss = helper ps' xs ss'
where ps' = ps ++ [x]
ss' = ss ++ [ps ++ xs]
in helper ls
λ> subOneLists [1, 2, 3, 4]
[[2,3,4],[1,3,4],[1,2,4],[1,2,3]]
haskell
New contributor
I am trying to write a Haskell function which takes a list ls
and returns all sub-lists obtained by removing one element from ls
. An additional constraint is that the returned list of lists must be in the order of the missing element.
Here is what I have. I know there must be a simpler solution.
subOneLists :: [a] -> [[a]]
subOneLists ls = let helper :: [a] -> [a] -> [[a]] -> [[a]]
helper _ ss = ss
helper ps (x:xs) ss = helper ps' xs ss'
where ps' = ps ++ [x]
ss' = ss ++ [ps ++ xs]
in helper ls
λ> subOneLists [1, 2, 3, 4]
[[2,3,4],[1,3,4],[1,2,4],[1,2,3]]
haskell
haskell
New contributor
New contributor
edited Nov 14 at 5:40
200_success
127k15148410
127k15148410
New contributor
asked Nov 14 at 3:24
Paul
1485
1485
New contributor
New contributor
add a comment |
add a comment |
3 Answers
3
active
oldest
votes
up vote
13
down vote
accepted
Here's a simpler way to implement it:
subOneLists :: [a] -> [[a]]
subOneLists =
subOneLists (x:xs) = xs : map (x :) (subOneLists xs)
This is really clever
– Paul
Nov 14 at 4:10
3
this repeats the oldinits
bug which makes(last $ subOneLists xs !! n)
quadratic inn
. My version as well as the newer, corrected version ofinits
in the library makes it linear.
– Will Ness
Nov 14 at 13:43
add a comment |
up vote
6
down vote
List as an abstract concept can have many representations.
In particular, with a list being represented by its "zipper" - a pairing of a reversed prefix and a suffix, it becomes possible to have a linear solution to this problem, as opposed to the quadratic one which is unavoidable with the plain linear representation :
picks :: [a] -> [([a], [a])]
picks =
picks (x:xs) = go [x] xs
where
go pref suff@(x:xs) = (pref,suff) : go (x:pref) xs
go pref = [(pref,)]
Using this, your problem becomes
foo = map ((a,b) -> revappend (tail a) b) . picks
revappend a b = foldl (flip (:)) b a
This is of course again quadratic, but maybe you could keep the prefixes reversed, to stay linear:
import Control.Arrow (first)
foo' = map (first tail) . picks -- or,
-- = map ((x,y) -> (tail x, y)) . picks
add a comment |
up vote
5
down vote
Look out for standard functions that can help you!
Prelude Data.List> let subOneLists ls = zipWith (++) (inits ls) (tail $ tails ls)
Prelude Data.List> subOneLists [1, 2, 3, 4]
[[2,3,4],[1,3,4],[1,2,4],[1,2,3]]
This uses the fact that the inits
- and tails
-elements at corresponding index always recombine to the original list, but with a variably splitting point:
Prelude Data.List> let ls = [0..7] in mapM_ print (zip (inits ls) (tails ls))
(,[0,1,2,3,4,5,6,7])
([0],[1,2,3,4,5,6,7])
([0,1],[2,3,4,5,6,7])
([0,1,2],[3,4,5,6,7])
([0,1,2,3],[4,5,6,7])
([0,1,2,3,4],[5,6,7])
([0,1,2,3,4,5],[6,7])
([0,1,2,3,4,5,6],[7])
([0,1,2,3,4,5,6,7],)
If you now “shift up” that tails
, by dropping its head, you effectively lose the head of each of the contained lists:
Prelude Data.List> let ls = [0..7] in mapM_ print (zip (inits ls) (tail $ tails ls))
(,[1,2,3,4,5,6,7])
([0],[2,3,4,5,6,7])
([0,1],[3,4,5,6,7])
([0,1,2],[4,5,6,7])
([0,1,2,3],[5,6,7])
([0,1,2,3,4],[6,7])
([0,1,2,3,4,5],[7])
([0,1,2,3,4,5,6],)
And that can just be ++
combined with the inits
again.
New contributor
makes me wonder that maybe there should berevinits
in the library somewhere...
– Will Ness
Nov 14 at 13:28
Would probably make more sense to make that a rewrite rule fortails . reverse
, if even necessary.
– leftaroundabout
Nov 14 at 13:44
I meantreversed_inits [1..] !! 10 == [10,9..1]
. :) (i.e.map reverse . inits
but linear)
– Will Ness
Nov 14 at 13:46
Ok,reverse . tails . reverse
... yeah, that's ah bit meh. Still – I don't think it's good to packbase
with every combination of reversal and disassembly. If you use any of these, then it's probably not optimal for performance anyway (compared to somethingData.Vector
based), and if performance isn't that critical then just combine simple list functions.
– leftaroundabout
Nov 14 at 13:51
1
see my updated comment. It's supposed to be linear, that's the point. and work for infinite inputs too.
– Will Ness
Nov 14 at 13:52
|
show 1 more comment
3 Answers
3
active
oldest
votes
3 Answers
3
active
oldest
votes
active
oldest
votes
active
oldest
votes
up vote
13
down vote
accepted
Here's a simpler way to implement it:
subOneLists :: [a] -> [[a]]
subOneLists =
subOneLists (x:xs) = xs : map (x :) (subOneLists xs)
This is really clever
– Paul
Nov 14 at 4:10
3
this repeats the oldinits
bug which makes(last $ subOneLists xs !! n)
quadratic inn
. My version as well as the newer, corrected version ofinits
in the library makes it linear.
– Will Ness
Nov 14 at 13:43
add a comment |
up vote
13
down vote
accepted
Here's a simpler way to implement it:
subOneLists :: [a] -> [[a]]
subOneLists =
subOneLists (x:xs) = xs : map (x :) (subOneLists xs)
This is really clever
– Paul
Nov 14 at 4:10
3
this repeats the oldinits
bug which makes(last $ subOneLists xs !! n)
quadratic inn
. My version as well as the newer, corrected version ofinits
in the library makes it linear.
– Will Ness
Nov 14 at 13:43
add a comment |
up vote
13
down vote
accepted
up vote
13
down vote
accepted
Here's a simpler way to implement it:
subOneLists :: [a] -> [[a]]
subOneLists =
subOneLists (x:xs) = xs : map (x :) (subOneLists xs)
Here's a simpler way to implement it:
subOneLists :: [a] -> [[a]]
subOneLists =
subOneLists (x:xs) = xs : map (x :) (subOneLists xs)
answered Nov 14 at 3:38
4castle
365212
365212
This is really clever
– Paul
Nov 14 at 4:10
3
this repeats the oldinits
bug which makes(last $ subOneLists xs !! n)
quadratic inn
. My version as well as the newer, corrected version ofinits
in the library makes it linear.
– Will Ness
Nov 14 at 13:43
add a comment |
This is really clever
– Paul
Nov 14 at 4:10
3
this repeats the oldinits
bug which makes(last $ subOneLists xs !! n)
quadratic inn
. My version as well as the newer, corrected version ofinits
in the library makes it linear.
– Will Ness
Nov 14 at 13:43
This is really clever
– Paul
Nov 14 at 4:10
This is really clever
– Paul
Nov 14 at 4:10
3
3
this repeats the old
inits
bug which makes (last $ subOneLists xs !! n)
quadratic in n
. My version as well as the newer, corrected version of inits
in the library makes it linear.– Will Ness
Nov 14 at 13:43
this repeats the old
inits
bug which makes (last $ subOneLists xs !! n)
quadratic in n
. My version as well as the newer, corrected version of inits
in the library makes it linear.– Will Ness
Nov 14 at 13:43
add a comment |
up vote
6
down vote
List as an abstract concept can have many representations.
In particular, with a list being represented by its "zipper" - a pairing of a reversed prefix and a suffix, it becomes possible to have a linear solution to this problem, as opposed to the quadratic one which is unavoidable with the plain linear representation :
picks :: [a] -> [([a], [a])]
picks =
picks (x:xs) = go [x] xs
where
go pref suff@(x:xs) = (pref,suff) : go (x:pref) xs
go pref = [(pref,)]
Using this, your problem becomes
foo = map ((a,b) -> revappend (tail a) b) . picks
revappend a b = foldl (flip (:)) b a
This is of course again quadratic, but maybe you could keep the prefixes reversed, to stay linear:
import Control.Arrow (first)
foo' = map (first tail) . picks -- or,
-- = map ((x,y) -> (tail x, y)) . picks
add a comment |
up vote
6
down vote
List as an abstract concept can have many representations.
In particular, with a list being represented by its "zipper" - a pairing of a reversed prefix and a suffix, it becomes possible to have a linear solution to this problem, as opposed to the quadratic one which is unavoidable with the plain linear representation :
picks :: [a] -> [([a], [a])]
picks =
picks (x:xs) = go [x] xs
where
go pref suff@(x:xs) = (pref,suff) : go (x:pref) xs
go pref = [(pref,)]
Using this, your problem becomes
foo = map ((a,b) -> revappend (tail a) b) . picks
revappend a b = foldl (flip (:)) b a
This is of course again quadratic, but maybe you could keep the prefixes reversed, to stay linear:
import Control.Arrow (first)
foo' = map (first tail) . picks -- or,
-- = map ((x,y) -> (tail x, y)) . picks
add a comment |
up vote
6
down vote
up vote
6
down vote
List as an abstract concept can have many representations.
In particular, with a list being represented by its "zipper" - a pairing of a reversed prefix and a suffix, it becomes possible to have a linear solution to this problem, as opposed to the quadratic one which is unavoidable with the plain linear representation :
picks :: [a] -> [([a], [a])]
picks =
picks (x:xs) = go [x] xs
where
go pref suff@(x:xs) = (pref,suff) : go (x:pref) xs
go pref = [(pref,)]
Using this, your problem becomes
foo = map ((a,b) -> revappend (tail a) b) . picks
revappend a b = foldl (flip (:)) b a
This is of course again quadratic, but maybe you could keep the prefixes reversed, to stay linear:
import Control.Arrow (first)
foo' = map (first tail) . picks -- or,
-- = map ((x,y) -> (tail x, y)) . picks
List as an abstract concept can have many representations.
In particular, with a list being represented by its "zipper" - a pairing of a reversed prefix and a suffix, it becomes possible to have a linear solution to this problem, as opposed to the quadratic one which is unavoidable with the plain linear representation :
picks :: [a] -> [([a], [a])]
picks =
picks (x:xs) = go [x] xs
where
go pref suff@(x:xs) = (pref,suff) : go (x:pref) xs
go pref = [(pref,)]
Using this, your problem becomes
foo = map ((a,b) -> revappend (tail a) b) . picks
revappend a b = foldl (flip (:)) b a
This is of course again quadratic, but maybe you could keep the prefixes reversed, to stay linear:
import Control.Arrow (first)
foo' = map (first tail) . picks -- or,
-- = map ((x,y) -> (tail x, y)) . picks
edited Nov 14 at 20:45
answered Nov 14 at 10:19
Will Ness
7371620
7371620
add a comment |
add a comment |
up vote
5
down vote
Look out for standard functions that can help you!
Prelude Data.List> let subOneLists ls = zipWith (++) (inits ls) (tail $ tails ls)
Prelude Data.List> subOneLists [1, 2, 3, 4]
[[2,3,4],[1,3,4],[1,2,4],[1,2,3]]
This uses the fact that the inits
- and tails
-elements at corresponding index always recombine to the original list, but with a variably splitting point:
Prelude Data.List> let ls = [0..7] in mapM_ print (zip (inits ls) (tails ls))
(,[0,1,2,3,4,5,6,7])
([0],[1,2,3,4,5,6,7])
([0,1],[2,3,4,5,6,7])
([0,1,2],[3,4,5,6,7])
([0,1,2,3],[4,5,6,7])
([0,1,2,3,4],[5,6,7])
([0,1,2,3,4,5],[6,7])
([0,1,2,3,4,5,6],[7])
([0,1,2,3,4,5,6,7],)
If you now “shift up” that tails
, by dropping its head, you effectively lose the head of each of the contained lists:
Prelude Data.List> let ls = [0..7] in mapM_ print (zip (inits ls) (tail $ tails ls))
(,[1,2,3,4,5,6,7])
([0],[2,3,4,5,6,7])
([0,1],[3,4,5,6,7])
([0,1,2],[4,5,6,7])
([0,1,2,3],[5,6,7])
([0,1,2,3,4],[6,7])
([0,1,2,3,4,5],[7])
([0,1,2,3,4,5,6],)
And that can just be ++
combined with the inits
again.
New contributor
makes me wonder that maybe there should berevinits
in the library somewhere...
– Will Ness
Nov 14 at 13:28
Would probably make more sense to make that a rewrite rule fortails . reverse
, if even necessary.
– leftaroundabout
Nov 14 at 13:44
I meantreversed_inits [1..] !! 10 == [10,9..1]
. :) (i.e.map reverse . inits
but linear)
– Will Ness
Nov 14 at 13:46
Ok,reverse . tails . reverse
... yeah, that's ah bit meh. Still – I don't think it's good to packbase
with every combination of reversal and disassembly. If you use any of these, then it's probably not optimal for performance anyway (compared to somethingData.Vector
based), and if performance isn't that critical then just combine simple list functions.
– leftaroundabout
Nov 14 at 13:51
1
see my updated comment. It's supposed to be linear, that's the point. and work for infinite inputs too.
– Will Ness
Nov 14 at 13:52
|
show 1 more comment
up vote
5
down vote
Look out for standard functions that can help you!
Prelude Data.List> let subOneLists ls = zipWith (++) (inits ls) (tail $ tails ls)
Prelude Data.List> subOneLists [1, 2, 3, 4]
[[2,3,4],[1,3,4],[1,2,4],[1,2,3]]
This uses the fact that the inits
- and tails
-elements at corresponding index always recombine to the original list, but with a variably splitting point:
Prelude Data.List> let ls = [0..7] in mapM_ print (zip (inits ls) (tails ls))
(,[0,1,2,3,4,5,6,7])
([0],[1,2,3,4,5,6,7])
([0,1],[2,3,4,5,6,7])
([0,1,2],[3,4,5,6,7])
([0,1,2,3],[4,5,6,7])
([0,1,2,3,4],[5,6,7])
([0,1,2,3,4,5],[6,7])
([0,1,2,3,4,5,6],[7])
([0,1,2,3,4,5,6,7],)
If you now “shift up” that tails
, by dropping its head, you effectively lose the head of each of the contained lists:
Prelude Data.List> let ls = [0..7] in mapM_ print (zip (inits ls) (tail $ tails ls))
(,[1,2,3,4,5,6,7])
([0],[2,3,4,5,6,7])
([0,1],[3,4,5,6,7])
([0,1,2],[4,5,6,7])
([0,1,2,3],[5,6,7])
([0,1,2,3,4],[6,7])
([0,1,2,3,4,5],[7])
([0,1,2,3,4,5,6],)
And that can just be ++
combined with the inits
again.
New contributor
makes me wonder that maybe there should berevinits
in the library somewhere...
– Will Ness
Nov 14 at 13:28
Would probably make more sense to make that a rewrite rule fortails . reverse
, if even necessary.
– leftaroundabout
Nov 14 at 13:44
I meantreversed_inits [1..] !! 10 == [10,9..1]
. :) (i.e.map reverse . inits
but linear)
– Will Ness
Nov 14 at 13:46
Ok,reverse . tails . reverse
... yeah, that's ah bit meh. Still – I don't think it's good to packbase
with every combination of reversal and disassembly. If you use any of these, then it's probably not optimal for performance anyway (compared to somethingData.Vector
based), and if performance isn't that critical then just combine simple list functions.
– leftaroundabout
Nov 14 at 13:51
1
see my updated comment. It's supposed to be linear, that's the point. and work for infinite inputs too.
– Will Ness
Nov 14 at 13:52
|
show 1 more comment
up vote
5
down vote
up vote
5
down vote
Look out for standard functions that can help you!
Prelude Data.List> let subOneLists ls = zipWith (++) (inits ls) (tail $ tails ls)
Prelude Data.List> subOneLists [1, 2, 3, 4]
[[2,3,4],[1,3,4],[1,2,4],[1,2,3]]
This uses the fact that the inits
- and tails
-elements at corresponding index always recombine to the original list, but with a variably splitting point:
Prelude Data.List> let ls = [0..7] in mapM_ print (zip (inits ls) (tails ls))
(,[0,1,2,3,4,5,6,7])
([0],[1,2,3,4,5,6,7])
([0,1],[2,3,4,5,6,7])
([0,1,2],[3,4,5,6,7])
([0,1,2,3],[4,5,6,7])
([0,1,2,3,4],[5,6,7])
([0,1,2,3,4,5],[6,7])
([0,1,2,3,4,5,6],[7])
([0,1,2,3,4,5,6,7],)
If you now “shift up” that tails
, by dropping its head, you effectively lose the head of each of the contained lists:
Prelude Data.List> let ls = [0..7] in mapM_ print (zip (inits ls) (tail $ tails ls))
(,[1,2,3,4,5,6,7])
([0],[2,3,4,5,6,7])
([0,1],[3,4,5,6,7])
([0,1,2],[4,5,6,7])
([0,1,2,3],[5,6,7])
([0,1,2,3,4],[6,7])
([0,1,2,3,4,5],[7])
([0,1,2,3,4,5,6],)
And that can just be ++
combined with the inits
again.
New contributor
Look out for standard functions that can help you!
Prelude Data.List> let subOneLists ls = zipWith (++) (inits ls) (tail $ tails ls)
Prelude Data.List> subOneLists [1, 2, 3, 4]
[[2,3,4],[1,3,4],[1,2,4],[1,2,3]]
This uses the fact that the inits
- and tails
-elements at corresponding index always recombine to the original list, but with a variably splitting point:
Prelude Data.List> let ls = [0..7] in mapM_ print (zip (inits ls) (tails ls))
(,[0,1,2,3,4,5,6,7])
([0],[1,2,3,4,5,6,7])
([0,1],[2,3,4,5,6,7])
([0,1,2],[3,4,5,6,7])
([0,1,2,3],[4,5,6,7])
([0,1,2,3,4],[5,6,7])
([0,1,2,3,4,5],[6,7])
([0,1,2,3,4,5,6],[7])
([0,1,2,3,4,5,6,7],)
If you now “shift up” that tails
, by dropping its head, you effectively lose the head of each of the contained lists:
Prelude Data.List> let ls = [0..7] in mapM_ print (zip (inits ls) (tail $ tails ls))
(,[1,2,3,4,5,6,7])
([0],[2,3,4,5,6,7])
([0,1],[3,4,5,6,7])
([0,1,2],[4,5,6,7])
([0,1,2,3],[5,6,7])
([0,1,2,3,4],[6,7])
([0,1,2,3,4,5],[7])
([0,1,2,3,4,5,6],)
And that can just be ++
combined with the inits
again.
New contributor
New contributor
answered Nov 14 at 11:18
leftaroundabout
1513
1513
New contributor
New contributor
makes me wonder that maybe there should berevinits
in the library somewhere...
– Will Ness
Nov 14 at 13:28
Would probably make more sense to make that a rewrite rule fortails . reverse
, if even necessary.
– leftaroundabout
Nov 14 at 13:44
I meantreversed_inits [1..] !! 10 == [10,9..1]
. :) (i.e.map reverse . inits
but linear)
– Will Ness
Nov 14 at 13:46
Ok,reverse . tails . reverse
... yeah, that's ah bit meh. Still – I don't think it's good to packbase
with every combination of reversal and disassembly. If you use any of these, then it's probably not optimal for performance anyway (compared to somethingData.Vector
based), and if performance isn't that critical then just combine simple list functions.
– leftaroundabout
Nov 14 at 13:51
1
see my updated comment. It's supposed to be linear, that's the point. and work for infinite inputs too.
– Will Ness
Nov 14 at 13:52
|
show 1 more comment
makes me wonder that maybe there should berevinits
in the library somewhere...
– Will Ness
Nov 14 at 13:28
Would probably make more sense to make that a rewrite rule fortails . reverse
, if even necessary.
– leftaroundabout
Nov 14 at 13:44
I meantreversed_inits [1..] !! 10 == [10,9..1]
. :) (i.e.map reverse . inits
but linear)
– Will Ness
Nov 14 at 13:46
Ok,reverse . tails . reverse
... yeah, that's ah bit meh. Still – I don't think it's good to packbase
with every combination of reversal and disassembly. If you use any of these, then it's probably not optimal for performance anyway (compared to somethingData.Vector
based), and if performance isn't that critical then just combine simple list functions.
– leftaroundabout
Nov 14 at 13:51
1
see my updated comment. It's supposed to be linear, that's the point. and work for infinite inputs too.
– Will Ness
Nov 14 at 13:52
makes me wonder that maybe there should be
revinits
in the library somewhere...– Will Ness
Nov 14 at 13:28
makes me wonder that maybe there should be
revinits
in the library somewhere...– Will Ness
Nov 14 at 13:28
Would probably make more sense to make that a rewrite rule for
tails . reverse
, if even necessary.– leftaroundabout
Nov 14 at 13:44
Would probably make more sense to make that a rewrite rule for
tails . reverse
, if even necessary.– leftaroundabout
Nov 14 at 13:44
I meant
reversed_inits [1..] !! 10 == [10,9..1]
. :) (i.e. map reverse . inits
but linear)– Will Ness
Nov 14 at 13:46
I meant
reversed_inits [1..] !! 10 == [10,9..1]
. :) (i.e. map reverse . inits
but linear)– Will Ness
Nov 14 at 13:46
Ok,
reverse . tails . reverse
... yeah, that's ah bit meh. Still – I don't think it's good to pack base
with every combination of reversal and disassembly. If you use any of these, then it's probably not optimal for performance anyway (compared to something Data.Vector
based), and if performance isn't that critical then just combine simple list functions.– leftaroundabout
Nov 14 at 13:51
Ok,
reverse . tails . reverse
... yeah, that's ah bit meh. Still – I don't think it's good to pack base
with every combination of reversal and disassembly. If you use any of these, then it's probably not optimal for performance anyway (compared to something Data.Vector
based), and if performance isn't that critical then just combine simple list functions.– leftaroundabout
Nov 14 at 13:51
1
1
see my updated comment. It's supposed to be linear, that's the point. and work for infinite inputs too.
– Will Ness
Nov 14 at 13:52
see my updated comment. It's supposed to be linear, that's the point. and work for infinite inputs too.
– Will Ness
Nov 14 at 13:52
|
show 1 more comment
Paul is a new contributor. Be nice, and check out our Code of Conduct.
Paul is a new contributor. Be nice, and check out our Code of Conduct.
Paul is a new contributor. Be nice, and check out our Code of Conduct.
Paul is a new contributor. Be nice, and check out our Code of Conduct.
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
StackExchange.ready(
function () {
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcodereview.stackexchange.com%2fquestions%2f207619%2fgiven-a-haskell-list-return-all-sub-lists-obtained-by-removing-one-element%23new-answer', 'question_page');
}
);
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Sign up or log in
StackExchange.ready(function () {
StackExchange.helpers.onClickDraftSave('#login-link');
});
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Sign up using Google
Sign up using Facebook
Sign up using Email and Password
Post as a guest
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown
Required, but never shown