4
\$\begingroup\$

I recently solved Project Euler Problem 14 in Python:

The following iterative sequence is defined for the set of positive integers:

n → n/2 (n is even)
n → 3n + 1 (n is odd)

Using the rule above and starting with 13, we generate the following sequence:

13 → 40 → 20 → 10 → 5 → 16 → 8 → 4 → 2 → 1

It can be seen that this sequence (starting at 13 and finishing at 1) contains 10 terms. Although it has not been proved yet (Collatz Problem), it is thought that all starting numbers finish at 1.

Which starting number, under one million, produces the longest chain?

NOTE: Once the chain starts the terms are allowed to go above one million.

But my code takes around 45 seconds to run. I'm looking for some basic ways to make my code more efficient, specifically in the function which calculates each sequence. I have heard in other answers that I should store operations that have already been completed, but how would I do this? I also feel like the method I use for sorting the sequence numbers is clunky and could be optimized.

My code:

import time
start = time.time()

def collatzSeq (n):
    chainNumber = 1
    n1 = n
    while n1 != 1:
        if n1 % 2 == 0:
            n1 = n1/2
            chainNumber += 1
        else:
            n1 = (3*n1) + 1
            chainNumber += 1
    return [chainNumber, n]

fullList = []
for i in range(2, 1000000):
    fullList.append(collatzSeq(i))
sortedList = sorted(fullList, reverse=True)
print(sortedList[:1])

print('Time:', 1000*(time.time() - start))
\$\endgroup\$
  • 2
    \$\begingroup\$ I would only keep the current max and length. Then you don't have to sort the array or keep 1M records in memory. Alternatively, memoizing should speed this up a lot (note, when solving 13, you have also solved 40, 20 and 16). Sorry, though I am not sure how to do that in python. \$\endgroup\$ – Kristian H Jul 8 '17 at 1:06
4
\$\begingroup\$

Memoization

Storing results that have already been computed is known as memoization. Your current function's structure wouldn't work very well since collatzSeq isn't recursive, and you only call it with unique values. After all, the real time savers would be with all the intermediate collatz sequence values.

Restructuring your code to be recursive would make setting up the memoization a lot easier:

def collatz_seq(n):      # no space after function, snake case preferred in python
    if n == 1:           # base case
        return 1
    elif n % 2 == 0:     # recursive definitions
        return collatz_seq(n // 2) + 1     # integer division
    else:
        return collatz_seq(3*n + 1) + 1

Recusion is where you define a function in terms of itself and a base stopping condition.

Now we can easily set up memization using a dictionary:

memo = {}                               # initialize the memo dictionary
def collatz_seq(n):
    if not n in memo:                   # check if already computed
        if n == 1:                      # if not compute it
            memo[n] = 1                 # cache it
        elif n % 2 == 0:
            memo[n] = collatz_seq(n // 2) + 1
        else:
            memo[n] = collatz_seq(3*n + 1) + 1
    return memo[n]                      # and return it

So what's going on here? First we create an empty dictionary called memo. It's crated outside the function so that it persists through each function call. Next check if collatzSeq(n) has already been computed. If not compute the value, and then store it in the memo. Finally return the chached result.

This is great since once a number's collatz sequence length is computed, it never needs to be computed again. This really saves on computation time!

For more memoizaiton info check out this great SO question.

Maximum Stack Depth

Python has a maximum stack depth of 1000 (by default) which sometimes messes with recursive functions if they go too deep. I don't how long the longest collatz sequence under 1000000 is, so I don't know if this is relevent to your problem. But if you run into issues, you can change the maximum depth.

\$\endgroup\$
  • 2
    \$\begingroup\$ For memoization you can use functools.lru_cache \$\endgroup\$ – Maarten Fabré Jul 9 '17 at 6:45
  • \$\begingroup\$ Assuming op doesn't know how memoization works. Linked SO question goes into detail about options like decorators and lru_cache \$\endgroup\$ – Joshua Dawson Jul 10 '17 at 6:07
2
\$\begingroup\$

Only keep max length and number no sorting necessary. Also you can discard any number that is an intermediate value as its sequence is always shorter than the current number.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.