确定一个列表是否有偶数个元素而不计算元素的数量

Question

Implement the isLengthEven :: [a] -> Bool function that decides if a list contains an even number of elements. In this exercise, using the length function or any other function that returns the number of elements of a list is prohibited. Hint: All we have to check is whether we can walk the entirety of the list through two by two or does the function miss an item at the very end.

For example: isLengthEven "Apple" == True , isLengthEven "Even" == True , isLengthEven [] == False

So far, I tried pattern matching and recursion, which is in my opinion the optimal way of doing this exercise. My code is as follows:

isLengthEven :: [a] -> Bool
isLengthEven [] = False
isLengthEven (x:[]) = False
isLengthEven (x:(y:[])) = True
isLengthEven (x:(y:(z:[]))) = False
isLengthEven (x:(y:(z:(q:[])))) = True
isLengthEven (x:xs) = isLengthEven (xs)

This returns the correct values up until I insert the fifth element into the list. It returns True for any number of elements above or equal to 5. I suppose there's a problem with the recursion part.

Answer 1

You need only two base cases here:

1. an empty list, which has as length 0 and thus should return True ; and
2. a singleton list which contains one element and thus has an odd length.

The recursive cases each time move two steps forward in the list, so:

isLengthEven :: [a] -> Bool
isLengthEven [] = True
isLengthEven [x] = False
isLengthEven (_:_:xs) = isLengthEven xs

Often one defines two functions: isLengthEven and isLengthOdd and thus these functions each time call each other recursively with:

isLengthEven :: [a] -> Bool
isLengthEven [] = True
isLengthEven (_:xs) =  xs

isLengthOdd :: [a] -> Bool
isLengthOdd [] = False
isLengthOdd (_:xs) =  xs

Answer 2

A single-stepping solution

Note that the excellent answer by Willem is already an optimized one.

If you prefer a straight unoptimized version and choose to disregard the hint, you can do with just the first and last clauses of your initial code. Like this:

-- warning: the following is incorect, needs changes:
isLengthEven :: [a] -> Bool
isLengthEven [] = False
isLengthEven (x:xs) = isLengthEven (xs)

Both clauses are incorrect, but it is easy to fix them:

isLengthEven :: [a] -> Bool
isLengthEven [] = True
isLengthEven (x:xs) = not (isLengthEven xs)

and taken together, these two clauses cover all possible situations.

As is, this function uses a lot of stack space for long inputs. This can be fixed thru the common argument-as-accumulator trick. Here:

isLengthEven :: [a] -> Bool
isLengthEven xs = go True xs  where
    go b   []    =  b
    go b (x:xs)  =  go (not b) xs

where the go auxiliary stepping function is tail-recursive.

With that change, my machine is getting 67% of the performance of the obvious but prohibited (even (length xs)) solution.