# Exploring Recursive Solutions to Determine Even or Odd Numbers in Python

Rate this post

π‘ Problem Formulation: This article explores different recursive methods in Python to determine if a number is even or odd. Programming enthusiasts often stumble upon the classic problem: given an integer `n`, determine whether it is even or odd without using iteration or the modulus operator. The desired output is a boolean value indicating `True` for even and `False` for odd numbers.

## Method 1: Subtract Two Until Base Case

This method involves creating a recursive function that subtracts two from the number until it reaches the base case of zero (even) or one (odd). The function signature would be `is_even(n: int) -> bool`.

Here’s an example:

```def is_even(n):
if n == 0:
return True
elif n == 1:
return False
else:
return is_even(n-2)

print(is_even(10))  # Should return True
print(is_even(11))  # Should return False
```

Output: True False

This function recursively calls itself, shaving off 2 from the number `n` each time until it gets down to 0 or 1 to determine if the number is even or odd. Although this method is easy to understand, it is not suitable for negative numbers and has a potential for a stack overflow error with very large inputs.

## Method 2: Flip a Boolean Flag

A technique to determine a number’s parity is to flip a boolean flag every time we recursively decrease the number by one. The initial boolean value reflects if zero is even, and each recursive call inverts this truth value up until the base case.

Here’s an example:

```def is_even(n):
if n == 0:
return True
else:
return not is_even(n-1)

print(is_even(10))  # Should return True
print(is_even(11))  # Should return False
```

Output: True False

In this approach, we utilize the property that the parity of an integer is the opposite of the parity of the integer one less than it. While elegantly straightforward, this method also suffers from the stack overflow error for large values of `n`, and does not handle negative input.

## Method 3: Modifying the Base Case for Negative Numbers

To handle negative numbers as well, a base case can be modified to return `False` when `n` equals -1. We then subtract or add two based on whether the number is negative or positive, respectively.

Here’s an example:

```def is_even(n):
if n == 0:
return True
elif n == -1:
return False
else:
return is_even(n + 2) if n < 0 else is_even(n - 2)

print(is_even(-10))  # Should return True
print(is_even(-11))  # Should return False
```

Output: True False

This method extends the applicability of the first method to negative numbers by considering an additional base case. However, the same limitations with regard to stack overflow for large absolute values of `n` still apply.

## Method 4: Halving the Number

The halving method uses the fact that a number is even if half of it is even. Here we repeatedly divide by two and round down until we reach 1 (odd) or 0 (even), without using actual division to maintain integer processing.

Here’s an example:

```def is_even(n):
if n in (0, 1):
return n == 0
return is_even(n//2)

print(is_even(10))  # Should return True
print(is_even(11))  # Should return False
```

Output: True False

This method efficiently narrows down the problem by halving the magnitude of the number in each step. It is more efficient but still limited by the depth of the recursion stack and doesn’t naturally handle negative numbers.

## Bonus One-Liner Method 5: Python’s Ternary Recursive Function

A compact and elegant solution in Python, this one-liner uses a ternary recursive function that keeps subtracting one until either 0 or 1 is reached, determining the parity.

Here’s an example:

```is_even = lambda n: True if n == 0 else False if n == 1 else is_even(n-2)

print(is_even(10))  # Should return True
print(is_even(11))  # Should return False
```

Output: True False

The one-liner uses a lambda function with a nested ternary operator to succinctly express the recursive definition of an even number. While compact, it maintains the same limitations regarding stack overflows and negative numbers.

## Summary/Discussion

• Method 1: Subtract Two Until Base Case. Simple and direct. Not suitable for negative numbers or very large inputs.
• Method 2: Flip a Boolean Flag. Easy to understand. Limited by recursion depth and does not support negative numbers.
• Method 3: Modifying the Base Case for Negative Numbers. Handles negatives. Still limited by recursion depth for large numbers.
• Method 4: Halving the Number. More efficient with positive numbers. Limited by recursion depth and doesn’t naturally handle negatives.
• Method 5: Python’s Ternary Recursive Function. Compact and elegant. The same recursion stack and negative number limitations apply.