Question

I’m trying to halt the for loop below once values (x,y) or (z,2) have been returned so that the value i doesn’t keep increasing, and simply halts when the if or elif condition is first

def maxPalindrome(theList):
    # students need to put some logic here
    maxcomplist = theList[:]
    maxcomplist.reverse()
    control = len(theList) - 1
    # exit if maxPalindrome is True
    for i in range(control):
        if maxcomplist[:] == theList[:]:
            x = 0
            y = len(theList)
            return (x, y)
            break
        elif maxcomplist[i:control] == theList[i:control]:
            successList = theList[i:control]
            z = i
            w = len(theList) - z - 1
            return (z, w)

How can I accomplish this?

Answer 1

As I wrote in a comment already: that function isn’t a recursive one at all.
Recursion means, that a function calls itself to complete it’s purpose. This call can be indirect, meaning that the function uses helper function that will call the first function again.
But your code doesn’t cover both cases.

A recursive function always have a certain architecture:

• the first thing after being called should be to test, if the primitive case (or one primitive case among options) has been reached. if so, it returns.

• If not it will compute whatever is needed and pass this results to itself again,
  untill the primitive case is reached, and the nested function calls will finish in one after the other.

One well-known usage of recursion is the quicksort algorithm:

def quicksort(alist):
    if len(alist) < 2: 
        return alist # primitive case: a list of size one is ordered

    pivotelement = alist.pop()
    # compute the 2 lists for the next recursive call
    left  = [element for element in alist if element < pivotelement]#left = smaller than pivotelemet
    right = [element for element in alist if element >= pivotelement]#left = greater than pivotelemet

    # call function recursively
    return quicksort(left) + [pivotelement] + quicksort(right)

So the “stop” must be the return of a primitive case. This is vital for recursion. You cannot just break out somehow.