Fixing Gap in Knowledge about recursion: base conditions and state - python-3.x

Question

I have a gap in knowledge with recursion. I understand the base case should terminate the recursion but I have difficulty choosing the correct one.
Moreover I have a problem in understanding how to manage states without updating the method signature.
Take for instance the problem of largest adjacent element products. My understanding of divide and conquer is:
1) divide the problem into smaller problems:
1.1) create a left array of the first two elements
1.2) create a right array by removing the first element
2) conquer by recursion:
2.1) repeat the function on the right array
2.2) choose a good base case to terminate
3) combine the solution
3.1) this is where things get tricky!?
3.2) for the task of multiplication, how do I persist the result
after each recursion when each new call will re-instantiate the
result list
A concrete example of this gap in knowledge is below: The base case I chose is when the list has fewer than two elements, then return 0. Of course that works except when the product of two elements is less than 0.
Returning None for the base case is a problem with the state, because in python3 None and int comparison throws an error.
TypeError: '>=' not supported between instances of 'int' and 'NoneType'
Complete code is below
def multiply(inputArray):
m = inputArray[0] * inputArray[1]
return m
def adjacentElementsProduct(inputArray):
# [3, 6, -2, -5, 7, 3]
if len(inputArray) <= 1:
# return 0
return None
left = inputArray[:2]
right = inputArray[1:]
result = []
result.append(adjacentElementsProduct(right))
m = multiply(left)
print(result, left, m)
if len(result) == 0:
result.append(m)
else:
if m >= result[0]:
result.insert(0, m)
return result[0]

Answer 1

Seem like you main problem is how to combine solutions. In every single iteration, what you need to combine is results of left array and right array.
how do I persist the result?
Just return max of left result and right result.
def adjacentElementsProduct(inputArray):
# [3, 6, -2, -5, 7, 3]
if len(inputArray) <= 1:
return None
left = inputArray[:2]
right = inputArray[1:]
m = multiply(left)
result = adjacentElementsProduct(right)
# combine solutions
if result is None:
return m
else:
return max(m, result)
Testcases:
print(adjacentElementsProduct([3]))
None
print(adjacentElementsProduct([3,6]))
18
print(adjacentElementsProduct([3, 6, -2, -5, 7, 3]))
21