Steven Horvatin

The Fibonacci sequence consists of these numbers {0, 1, 1, 2, 3, 5, 8, 13, 21, 34…}. Intuitively, one can see that the next number in the sequence will be a summation of the current number and the previous number. The Fibonacci sequence written recursively is:

public static int fibRecursive(int n) {
        if(n < 0){
            throw new IllegalArgumentException("n < 0");
        }
        if (n <= 1)
            return n;
        return fibRecursive(n - 1) + fibRecursive(n - 2);
}

Behind the scenes, each recursive function call gets pushed on the stack as a stack frame therefore we can emulate recursion calls using a stack:

public static int fibUsingStack(int n) {
        if(n < 0){
            throw new IllegalArgumentException("n < 0");
        }
        Stack<Integer> stack = new Stack<>();
        stack.push(n);
        int sum = 0;
        while (!stack.empty()) {
            Integer next = stack.pop();
            if (next == 0 || next == 1) {
                sum += next;
                continue;
            }
            stack.push(next - 2);
            stack.push(next - 1);
        }
        return sum;
}

This is just a fun learning exercise which helps create understanding on how to convert recursive functions to iterative functions. It wouldn’t make sense to use a stack for this use case.

Math.random() generates a double between 0 inclusive and 1 exclusive. An easier way to think of this is that Math.random() generates a random double between [0, 1) where “[” is inclusive and “)” is exclusive.

I like this notation better because it helps to make a connection between programming classes and math classes. This connection makes it easier to understand how to generate integers with Math.random() because the experience shifting graphs in math will transfer over to generating random numbers.

So to generate an integer between a certain range, we can just shift the decimal generation and then cast it to an integer. It is important to note that an integer cast will always round down.

//Random decimal between [0, 1)

double randomDecimalBetweenZeroAndOne = Math.random();

//Random integer between [0 * 10, 1 * 10) which equals [0, 10)

int randomIntegerBetweenZeroAndNineInclusive = (int) (Math.random() * 10);

//Random integer between [0*6 + 5, 1*6 + 5) which equals [5, 11)

int randomIntegerBetweenFiveAndTenInclusive = (int)(Math.random() * 6 + 5)

Can you figure out how to write an inclusive method to generate random numbers? Comment below!