Python：使用递归有效地确定因素之和

Question

def sof (x, fact):
    if x % fact == 0:
        if fact >= x/fact:
            return fact + x/fact + sof (x,fact - 1)
        else:
            return 1
    else:
        return sof (x,fact-1)

How can I make this program more efficient runtime wise? I am personally exhausted of ideas.

Answer 1

I want to be able to run numbers over 4000 without exceeding my recursive limit

Here's one way to make the program more efficient , though not necessarily faster . In your code the base case of the recursion:

if fact >= x // fact:

is nested inside the remainder check:

if x % fact == 0:

Making it possible for your code to keep checking numbers that it doesn't need to. (Eg consider a large prime * 2 -- your code keeps checking until fact reaches 1 instead of the halfway point.)

This isn't a speed issue for the small numbers that this algorithm can handle before the stack overflows. You only reach 1999 beyond which the stack overflows whereas my rearrangement:

def sof(number, divisor):
    dividend = number // divisor

    if dividend > divisor:
        return 1

    if number % divisor:
        return sof(number, divisor - 1)

    return divisor + dividend + sof(number, divisor - 1)

can reach 2086 with the same stack size as it avoids those extra recursions.

And that difference increases as you expand the stack via sys.setrecursionlimit() .