An exponential big-O is represented by: O(c^n)

The n in an exponential problem means that the time of each consecutive computation of n will increase by c^n.

Recursively computing the Fibonacci sequence is a simple example of exponential big-O problems.  Let’s take a look:

package main

import "fmt"

func main() {
    fmt.Println(fib(40))
}

func fib(n int) int {
    if n <= 1 {
        return n
    } else {
        return fib(n-1) + fib(n-2)
    }
}

The time it would take to run (aka runtime) the operation above should be computed with O(1.6^40) and here’s why Fibonacci requires 1.6 for a constant

There are many factors that contribute to runtime with clock rate and  ISA implementation being the two most influential, but let’s say that  we are running on a system that is capable of returning a result from  the fib function every 15 nanoseconds.  Given that, it would take 15 * (1.6^40^) nanoseconds to complete this task.  This roughly equates to 2.19 seconds.

Just for fun: To exceed a million years, n would need to be greater than 104.  Here’s the calculation

Using a technique called memoization, each final computed value could  be stored in such a way that it can be referenced instead of being  computed again.  This changes the computational complexity to O(n) since each computation need not be performed more than once.

If you would like to run my code above, you can do so here.