#1, #2, #4 : EXPLANATION
The README for your project should be about the project. Therefore, your personal bio belongs elsewhere.

#4 EXPLANATION
Your MVP is the minimum viable product that it takes to "go to market", even if "market" just means sharing it with other people.

#2 EXPLANATION
Look at the top of the repository pages. Those stars mean popularity! Don't you want to be popular? Get people to "star" your repository for fame and success! (:shrug:)

#1, #2, #4 :EXPLANATION
Having a single repository is like showing up for school without being prepared. Many focused repositories, even if they're old, can show that you're interested in this craft of software engineering.

#2 EXPLANATION
It's all about the backticks. Those indicate that it should be considered code.

#3 EXPLANATION
If code is about people, then GitHub is the social platform on which that happens. Your profile on GitHub speaks about who you are, what your interests are in, and shows the type of code you can create.

ANSWER

O(n^m)

O(mⁿ)

O(log(n))

O(n)

O(n*log(n))

O(1)

1. O(1) : constant
2. O(log(n)) : logarithmic
3. O(n) : linear
4. O(n * log(n)) : loglinear
5. O(n^m) : polynomial
6. O(mⁿ) : exponential
7. O(n!) : factorial

Constant : O(1)

O(1) : Constant; Why? Because there are a fixed number of loops in the for loop. The for loop is not dependent upon n.

logarithmic: O(log(n)) : because the recursion will half the size of n each time

logarithmic: O(log(n)) : Because the while loop will half the size of n each time.

Linear : O(n) : Because the for loop will iterate n times

Linear : O(n) : Because the recursive call will be made n times.

O(n * log(n)) : LogLinear because the for loop will run n times; then the myFunction will be called recursively 2(log(n)) so we can drop the constant and consider log(n). Combining the for loop time complexity of O(n) and the recursive calls of log(n) we have O(n*log(n));

Polynomial : O(n²) : The outer loop will run n times; but for every time the outler loop runs, the inner loop will run n times; n * n = n² so we have O(n²)

Polynomial O(n³) : Because the outer for (i) will run n times, and for each time the outer loop runs the inner (j) will run n times - which is n * n - and there's another inner loop (k) that will run n times - so we have n*n*n which is n³ so we have O(n³)

Exponential : O(2ⁿ) : Because each call will make two more recursive calls so they will run a total of 2ⁿ times, or O(2ⁿ)

Exponential : O(3ⁿ) : Because each call will make 3 more recursive calls, n times.

Factorial : O(n!) : The code is recursive, but the number of recursive calls made in a a single stack frame depends on the input. So in this case, the for loop executes n times; but within the for loop the recursive call is made n-1 times. So you have n * n-1 * n-2 * n-3 ... or O(n!);

Bubble Sort. Time complexity O(n²); Space Complexity of O(1)

Selection Sort : Time complexity O(n²) and O(1) space complexity

Insertion Sort. Time Complexity: O(n²), Space complexity: O(1)

Merge Sort : Time Complexity O(n log(n)) since we split the array in half each time, the number of calls is O(log(n). The while loop inside the doSomething (aka merge) method will go through all of the array - n times. So it's O(n * log(n));

Space complexity is O(n), because we are copying the array n times. [Yes, there are two copies, but each is half of the array.]

QuickSort: Time complexity of O(n²) because sort on the left is O(n) and sort on the right is O(n).

Space complexity of Quick Sort is O(n);

Binary Search - Time complexity O(log(n));

Space complexity O(n)

    const fibonacci = (n, memo = {0: 0, 1:1} ) => {
    if (n in memo) return memo[n];
    memo[n] = fibonacci(n-1, memo) + fibonacci(n - 2, memo);
    return memo[n];
};

    function fibonacci(n) {
        let table = new Array(n);
        table[0] = 0;
        table[1] = 1;

        for (let i = 2; i <= n; i += 1) {
            table[i] = table[i-1] + table[i-2];
        }
        return table[n];
    }

Time complexity: O(n²); The outer loop i contributes O(n) in isolation. The inner while loop will contribute roughly O(n/2) on average. The two loops are nested so our total time complexity is O(n * n / 2) = O(n²).

Space Complexity: O(1); We use the same amount of memory and create the same amount of variables regardless of the size of our input.

    function insertionSort(list) {
        for (let i = 1; i < list.length; i++) {
            value = list[i];
            hole = i;

            while (hole > 0 && list[hole - 1] > value) {
                list[hole] = list[hole - 1];
                hole--;
            }
            list[hole] = value;
        }
    }

Time Complexity: O(n * log(n)); Since we split the array in half each time, the number of recursive calls is O(log(n)). The while loop within the merge function contributes O(n) in isolation and we call that for every recursive mergeSort call.
Space Complexity: O(n) : We will create a new subarray for each element in the original input.

    function merge(array1, array2) {
        let result = [];
        while (array1.length && array2.length) {
            if (array1[0] < array2[0]) {
                result.push(array1.shift());
            } else {
                result.push(array2.shift());
            }
        }
        return [...result, ...array1, ...array2];
    }

    function mergeSort(array) {
        if (array.length <= 1) return array;

        const mid = Math.floor(array.length / 2);
        const left = mergeSort(array.slice(0, mid));
        const right = mergeSort(array.slice(mid));

        return merge(left, right);
    }

Time Complexity: Avg Case: O(n log(n)) : The partition step alone is O(n). We are lucky and always choose the median as the pivot. This will halve the array length at every step of the recursion for O(log(n)).

Worst Case: O(n²): We are unlucky and always choose the min or max as the pivot. This means one partition will contain everything, and the other partition is empty, yielding O(n).

Space Complexity: O(n) : Our implementation of quickSort uses O(n) space because of the partition arrays we create.

    function quickSort(array) {
        if (array.length <= 1) return array;

        let pivot = array.shift();

        let left = array.filter(x => x < pivot);
        let right = array.filter(x => x >= pivot);

        let sortedLeft = quickSort(left);
        let sortedRight = quickSort(right);

        return [...sortedLeft, pivot, ...sortedRight];
    }

Time Complexity: O(log(n)) : The number of recursive calls is the number of times we must halve the array until it's length becomes 0.

Space Complexity: O(n) : Our implementation uses n space due to half arrays we create using slice.

    function binarySearch(list, target) {
        if (list.length === 0) return false;

        let mid = Math.floor(list.length / 2;

        if (list[mid] === target) {
            return true;
        } else if (list[mid] > target) {
            return binarySearch(list.slice(0, mid, target);
        } else {
            return binarySearch(list.slice(mid+1), target);
        }
    }

List: head, tail; length;
Node: value; next;

1. constructor(value)
2. addHead(value)
3. addTail(value)
4. insertAt(idx)
5. removeTail()
6. removeHead()
7. remove(idx)
8. contains(value)
9. set(value, idx)
10. size

LIFO : Last in (goes on top of the stack), Last out (removed from top of the stack)

Node: value; next;
Stack: top; length;

1. push(val)
2. pop()
3. size()

FIFO : First in First Out;

Node: value; next;
Queue: front; back; length;

1. enqueue(value) : to add the new node to the back of the queue
2. dequeue: removes a value from the front of the queue
3. size: Returns the size of the queue

bubbleSort will look at every element of the array, comparing it to the next element. If the next element is smaller, we will swap that element. We continue that to the end of the array. Each time we swap we set swapped to true. We continue iterating through the array until we've made it all the way through the array without swapping any elements.

Selection Sort is very similar to Bubble Sort. The major difference between the two is that Bubble Sort bubbles the largest elements up to the end of the array, while Selection Sort selects the smallest elements of the array and directly places them at the beginning of the array in sorted position. Selection sort will utilize swapping just as bubble sort did.

Insertion Sort is similar to Selection Sort in that it gradually builds up a larger and larger sorted region at the left-most end of the array. However, Insertion Sort differs from Selection Sort because this algorithm does not focus on searching for the right element to place (the next smallest in our Selection Sort) on each pass through the array. Instead, it focuses on sorting each element in the order they appear from left to right, regardless of their value, and inserting them in the most appropriate position in the sorted region.

Merge sort is based on the premise that it's easy to merge elements of two sorted arrays into a single sorted array. This screams recursion, with your base case being an empty array. Also, if there's only one element in the array you can consider that array as sorted.

1. choose an element called "the pivot", how that's done is up to the implementation
2. take two variables to point left and right of the list excluding pivot
3. left points to the low index
4. right points to the high
5. while value at left is less than pivot move right
6. while value at right is greater than pivot move left
7. if both step 5 and step 6 does not match swap left and right
8. if left >= right, the point where they met is new pivot
9. repeat, recursively calling this for smaller and smaller arrays

Binary search only works on sorted trees or lists. Cut the list in half, look at the end element of the left half and if it's greater than what you're looking for, choose your next search for the right element. Otherwise, choose your lefthalf for your next search. Rinse and repeat.

Take for example, using the binary search algorithm on an array of integers:

Looking for the element 5, will cut your search space in 1/2 with each attempt: