Completed constant, linear, and quadratic time complexities

Author: CoffeelessProgrammer

.gitignore

@@ -0,0 +1 @@
+deno_dir

Big-O/Ex1.ts

@@ -0,0 +1,24 @@
+// Exercise 1 -----------------------------------------
+
+function anotherFunction() {
+  // unknown runtime
+}
+
+function funChallenge(input: Array<any>): number {
+  let a = 10;   // O(1)
+  a = 50 + 3;   // O(1)
+
+  for (let i = 0; i < input.length; i++) {    // O(n)
+    anotherFunction();      // O(n)
+    let stranger = true;    // O(n)
+    a++;                    // O(n)
+  }
+
+  return a;     // O(1)
+}
+
+
+
+const numbersArr = [1,2,3,4,5];
+
+funChallenge(numbersArr);   // Time Complexity: O(3 + 4n) ~ O(n)

Big-O/Ex2.ts

@@ -0,0 +1,22 @@
+// Exercise 2 -----------------------------------------
+
+function anotherFunChallenge(input: number): void {
+  let a = 5;    // O(1)
+  let b = 10;   // O(1)
+  let c = 50;   // O(1)
+
+  for (let i = 0; i < input; i++) {   // O(n)
+    let x = i + 1;   // O(n)
+    let y = i + 2;   // O(n)
+    let z = i + 3;   // O(n)
+  }
+
+  for (let j = 0; j < input; j++) {   // O(n)
+    let p = j * 2;   // O(n)
+    let q = j * 2;   // O(n)
+  }
+
+  let whoAmI = "I don't know";   // O(1)
+}
+
+anotherFunChallenge(7); // Time Complexity: O(4 + 7n) ~ O(n)

Big-O/Hello_Big_O.ts

@@ -0,0 +1,32 @@
+
+const nemo = ['nemo'];
+const fishColony = ['dory', 'bruce', 'marlin', 'nemo', 'gill', 'bloat', 'nigel', 'squirt', 'darla', 'hank'];
+const largeArr = new Array(10000000).fill('squish');
+
+function findNemo(fishes: Array<string>): string {
+  let t0 = performance.now();   // O(1)
+
+  let isNemoFound = false;      // O(1)
+
+  for (let i = 0; i < fishes.length; i++) {   // O(n)
+    if (fishes[i] === 'nemo') {   // O(n)
+      isNemoFound = true;         // O(n)
+      break;                      // O(1)
+    }
+  }
+
+  let t1 = performance.now();     // O(1)
+  console.log("Call to find Nemo took " + (t1 - t0) + "ms.");   // O(1)
+
+  return isNemoFound ? "Found NEMO!" : "Where did Nemo go?!";   // O(1)
+}
+
+function getFirstFish(fishes: Array<string>) {
+    return fishes[0].charAt(0).toUpperCase() + fishes[0].substring(1).toLowerCase();  // O(1)
+}
+
+
+
+console.log(findNemo(fishColony));  // Time Complexity: O(n)
+console.log(findNemo(largeArr));    // Time Complexity: O(n)
+console.log(getFirstFish(fishColony), "just keeps swimming!");  // Time Complexity: O(1)

Big-O/README.md

@@ -1 +1,33 @@
-# Big O Notation
+# Algorithm Time-Complexity Analysis
+**Goal:** Understand how the runtime of an algorithm is affected by an increasing number of elements.
+
+## 5 Rules
+1. Analyze the worst case performance of the algorithm, i.e. Big O
+2. Add steps in order (+); multiply nested steps (*)
+3. Different inputs should have different variables, e.g. O(a+b)
+4. Remove constants
+5. Drop non-dominants
+
+## 3 Types
+### 1. Big O – Worst Case
+
+#### Ideal
+O(1) – Constant  
+O(log n) – Logarithmic  
+O(n) – Linear  
+
+#### Acceptable
+O(n * log n) – Log Linear  
+
+#### Avoid
+O(n^2) – Quadratic  
+O(2^n) – Exponential  
+O(n!) – Factorial  
+
+### 2. Big Θ – Average/Tight Case
+### 3. Big Ω – Best Case
+
+## Resources
+
+- [Big-O Algorithm Complexity Cheat Sheet (Know Thy Complexities!) @ericdrowell](https://www.bigocheatsheet.com/ "Big O Cheat Sheet")
+- [Practical Java Examples of the Big O Notation](https://www.baeldung.com/java-algorithm-complexity "Big O Examples")

Big-O/Rule3.ts

@@ -0,0 +1,14 @@
+// Rule 3: Different inputs should have different variables.--------------------
+
+function compressBoxes(fullBoxes: Array<string>, emptyBoxes: Array<string>) {
+  
+  fullBoxes.forEach((box) => { // O(a)
+    console.log(box);
+  });
+
+  emptyBoxes.forEach((box) => { // O(b)
+    console.log(box);
+  });
+}
+
+// Time Complexity: O(a+b)

Big-O/n_squared.ts

@@ -0,0 +1,30 @@
+// Examples of Quadratic Big O Runtime — O(n^2) ------------------
+
+const boxes = ["a", "b", "c", "d", "e"];
+
+function logAllPairs(array: Array<any>): void {
+  for (let i = 0; i < array.length; i++) {        // O(n)
+    for (let j = 0; j < array.length; j++) {        // O(n)
+      console.log(array[i], array[j]);              // O(n)
+    }
+  }
+}
+
+function printNumbersThenPairSums(numbers: Array<number>): void {
+  console.log("these are the numbers:");
+  numbers.forEach(function (number) {             // O(n)
+    console.log(number);
+  });
+
+  console.log("and these are their sums:");
+  numbers.forEach(function (firstNumber) {        // O(n)
+    numbers.forEach(function (secondNumber) {       // O(n)
+      console.log(firstNumber + secondNumber);      // O(n)
+    });
+  });
+}
+
+
+logAllPairs(boxes); // O(n * 2n) ~ O(n^2)
+
+printNumbersThenPairSums([1, 2, 3, 4, 5]);  // O(n + n*2n) ~ O(n^2)

README.md

@@ -1 +1 @@
-# Data Structures & Algorithms in Typescript
+# Data Structures & Algorithms in TypeScript