Question

int foo(int n) 
{
    int x=2;
    while (x<n)
    {
        x = x*x*x;
    }

    return x;
}

I need to analyze its time complexity. I noticed it reaches n much faster than just log(n). I mean, it does less steps than O(log(n)) would do. I read the answer but have no idea how they got to it: It is O(log(log(n)). Now, how do you approach such a question?

Answer 1

Let

L3 = log to the base 3
L2 = Log to the base 2

Then the correct answer is O(L3(L2(n)) and NOT O(L2(L2(n)).

Start with x = x * 2. x will increase exponentially till it reaches n, thus making the time complexity O(L2(n))

Now consider x = x * x. x increases faster than the above. In every iteration the value of x jumps to the square of its previous value. Doing some simple math, here is what we get:

For x = 2
n = 4, iterations taken = 1
n = 16, iterations taken = 2
n = 256, iterations taken = 3
n = 65536, iterations taken = 4

Thus, the time complexity is O(L2(L2(n)). You can verify this by putting values above values for n.

Now coming to your problem, x = x * x * x. This will increase even faster than x = x * x. Here is the table:

For x = 2
n = 8, iterations taken = 1
n = 512, iterations taken = 2
n = (512*512*512), iterations taken = 3 and so on

If you look at this carefully, this turns out to be O(L3(L2(n)). L2(n) will get you the power of two, but since you are taking cube of x in every iteration, you will have to take log to the base 3 of it to find out the correct number of iteration taken.

So I think the correct answer is O(log-to-base-3(log-to-base-2(n))

Generalizing this, if x = x * x * x * x * .. (k times), then the time complexity is O(log-to-base-k(log-to-base-2(n)