big o - Python Time Complexity (run-time)

Question

def f2(L):
    sum = 0
    i = 1
    while i < len(L):
        sum = sum + L[i]
        i = i * 2
    return sum

Let n be the size of the list L passed to this function. Which of the following most accurately describes how the runtime of this function grow as n grows?

(a) It grows linearly, like n does. (b) It grows quadratically, like n^2 does.

(c) It grows less than linearly. (d) It grows more than quadratically.

I don't understand how you figure out the relationship between the runtime of the function and the growth of n. Can someone please explain this to me?

Answer 1

ok, since this is homework:

this is the code:

def f2(L):
    sum = 0
    i = 1
    while i < len(L):
        sum = sum + L[i]
        i = i * 2
    return sum

it is obviously dependant on len(L).

So lets see for each line, what it costs:

sum = 0
i = 1
# [...]
return sum

those are obviously constant time, independant of L. In the loop we have:

    sum = sum + L[i] # time to lookup L[i] (`timelookup(L)`) plus time to add to the sum (obviously constant time)
    i = i * 2 # obviously constant time

and how many times is the loop executed? it's obvously dependant on the size of L. Lets call that loops(L)

so we got an overall complexity of

loops(L) * (timelookup(L) + const)

Being the nice guy I am, I'll tell you that list lookup is constant in python, so it boils down to

O(loops(L)) (constant factors ignored, as big-O convention implies)

And how often do you loop, based on the len() of L?

(a) as often as there are items in the list (b) quadratically as often as there are items in the list?

(c) less often as there are items in the list (d) more often than (b) ?