Merge pull request #257 from loiane/loiane/p2-ts-migrations

feat: P2 TypeScript migrations — set, recursion, bigO, heap

Author: loiane

src/02-bigOnotation/01-big-o-intro.ts

@@ -0,0 +1,71 @@
+export {};
+
+// O(1) - Constant Time
+function secondsInDays(numberOfDays: number): number {
+  if (numberOfDays <= 0 || !Number.isInteger(numberOfDays)) {
+    throw new Error('Invalid number of days');
+  }
+  return 60 * 60 * 24 * numberOfDays;
+}
+
+console.log('O(1) - Constant Time');
+console.log('Seconds in 1 day: ', secondsInDays(1)); // 86400
+console.log('Seconds in 10 days: ', secondsInDays(10)); // 864000
+console.log('Seconds in 100 days: ', secondsInDays(100)); // 8640000
+
+// O(n) - Linear Time
+function calculateTotalExpenses(monthlyExpenses: number[]): number {
+  let total = 0;
+  for (let i = 0; i < monthlyExpenses.length; i++) {
+    total += monthlyExpenses[i]!;
+  }
+  return total;
+}
+
+console.log('*******************');
+console.log('O(n) - Linear Time');
+console.log('January: ', calculateTotalExpenses([100, 200, 300])); // 600
+console.log('February: ', calculateTotalExpenses([200, 300, 400])); // 900
+console.log('March: ', calculateTotalExpenses([30, 40, 50, 100, 50])); // 270
+
+// O(n^2) - Quadratic Time
+function calculateExpensesMatrix(monthlyExpenses: number[][]): number {
+  let total = 0;
+  for (let i = 0; i < monthlyExpenses.length; i++) {
+    for (let j = 0; j < monthlyExpenses[i]!.length; j++) {
+      total += monthlyExpenses[i]![j]!;
+    }
+  }
+  return total;
+}
+
+console.log('************************');
+console.log('O(n^2) - Quadratic Time');
+const monthlyExpenses = [
+  [100, 105, 100, 115, 120, 135],
+  [180, 185, 185, 185, 200, 210],
+  [30, 30, 30, 30, 30, 30],
+  [2000, 2000, 2000, 2000, 2000, 2000],
+  [600, 620, 610, 600, 620, 600],
+  [150, 100, 130, 200, 150, 100]
+];
+console.log('Total expenses: ', calculateExpensesMatrix(monthlyExpenses)); // 18480
+
+// calculating the time complexity of the function calculateExpensesMatrix
+function multiplicationTable(num: number, x: number): void {
+  let s = '';
+  const numberOfAsterisks = num * x;
+  for (let i = 1; i <= numberOfAsterisks; i++) {
+    s += '*';
+  }
+  console.log(s);
+
+  for (let i = 1; i <= num; i++) {
+    console.log(`Multiplication table for ${i} with x = ${x}`);
+    for (let j = 1; j <= x; j++) {
+      console.log(`${i} * ${j} = `, i * j);
+    }
+  }
+}
+
+// to see the output of this file use the command: node src/02-bigOnotation/01-big-o-intro.ts

src/02-bigOnotation/03-exercises.ts

@@ -0,0 +1,57 @@
+export {};
+
+/* What is the time and space complexities for each of the following functions.
+   Try them with different inputs to explore how they behave with different inputs */
+
+// time complexity: O(1) - Constant Time
+// space complexity: O(1) - Constant Space
+const oddOrEven = (array: unknown[]): string => array.length % 2 === 0 ? 'even' : 'odd';
+
+console.log(oddOrEven([1, 2, 3, 4, 5])); // odd
+console.log(oddOrEven([1, 2, 3, 4, 5, 6])); // even
+
+// time complexity: O(n) - Linear Time
+// space complexity: O(1) - Constant Space
+function calculateAverage(array: number[]): number {
+  let sum = 0;
+  for (let i = 0; i < array.length; i++) {
+    sum += array[i]!;
+  }
+  return sum / array.length;
+}
+
+console.log(calculateAverage([1, 2, 3, 4, 5])); // 3
+console.log(calculateAverage([1, 2, 3, 4, 5, 6])); // 3.5
+
+// time complexity: O(n^2) - Quadratic Time
+// space complexity: O(1) - Constant Space
+function hasCommonElements(array1: number[], array2: number[]): boolean {
+  for (let i = 0; i < array1.length; i++) {
+    for (let j = 0; j < array2.length; j++) {
+      if (array1[i] === array2[j]) {
+        return true;
+      }
+    }
+  }
+  return false;
+}
+
+console.log(hasCommonElements([1, 2, 3, 4, 5], [6, 7, 8, 9, 10])); // false
+console.log(hasCommonElements([1, 2, 3, 4, 5], [5, 6, 7, 8, 9])); // true
+
+// time complexity: O(n) - Linear Time
+// space complexity: O(n) - Linear Space
+function getOddNumbers(array: number[]): number[] {
+  const result: number[] = [];
+  for (let i = 0; i < array.length; i++) {
+    if (array[i]! % 2 !== 0) {
+      result.push(array[i]!);
+    }
+  }
+  return result;
+}
+
+console.log(getOddNumbers([1, 2, 3, 4, 5])); // [1, 3, 5]
+console.log(getOddNumbers([1, 2, 3, 4, 5, 6])); // [1, 3, 5]
+
+// to see the output of this file use the command: node src/02-bigOnotation/03-exercises.ts

src/07-set/set.ts

@@ -0,0 +1,105 @@
+class MySet {
+  #items: Record<string, boolean> = {};
+  #size = 0;
+
+  add(value: string): boolean {
+    if (!this.has(value)) {
+      this.#items[value] = true;
+      this.#size++;
+      return true;
+    }
+    return false;
+  }
+
+  addAll(values: string[]): void {
+    values.forEach(value => this.add(value));
+  }
+
+  delete(value: string): boolean {
+    if (this.has(value)) {
+      delete this.#items[value];
+      this.#size--;
+      return true;
+    }
+    return false;
+  }
+
+  has(value: string): boolean {
+    return Object.prototype.hasOwnProperty.call(this.#items, value);
+  }
+
+  values(): string[] {
+    return Object.keys(this.#items);
+  }
+
+  get size(): number {
+    return this.#size;
+  }
+
+  getSizeWithoutSizeProperty(): number {
+    let count = 0;
+    for (const key in this.#items) {
+      if (Object.prototype.hasOwnProperty.call(this.#items, key)) {
+        count++;
+      }
+    }
+    return count;
+  }
+
+  isEmpty(): boolean {
+    return this.#size === 0;
+  }
+
+  clear(): void {
+    this.#items = {};
+    this.#size = 0;
+  }
+
+  union(otherSet: MySet): MySet {
+    const unionSet = new MySet();
+    this.values().forEach(value => unionSet.add(value));
+    otherSet.values().forEach(value => unionSet.add(value));
+    return unionSet;
+  }
+
+  intersection(otherSet: MySet): MySet {
+    const intersectionSet = new MySet();
+    const [smallerSet, largerSet] = this.size <= otherSet.size ? [this, otherSet] : [otherSet, this];
+    smallerSet.values().forEach(value => {
+      if (largerSet.has(value)) {
+        intersectionSet.add(value);
+      }
+    });
+    return intersectionSet;
+  }
+
+  difference(otherSet: MySet): MySet {
+    const differenceSet = new MySet();
+    this.values().forEach(value => {
+      if (!otherSet.has(value)) {
+        differenceSet.add(value);
+      }
+    });
+    return differenceSet;
+  }
+
+  isSubsetOf(otherSet: MySet): boolean {
+    if (this.size > otherSet.size) {
+      return false;
+    }
+    return this.values().every(value => otherSet.has(value));
+  }
+
+  isSupersetOf(otherSet: MySet): boolean {
+    if (this.size < otherSet.size) {
+      return false;
+    }
+    return otherSet.values().every(value => this.has(value));
+  }
+
+  toString(): string {
+    return this.values().join(', ');
+  }
+}
+
+export default MySet;

src/09-recursion/02-factorial.ts

@@ -0,0 +1,28 @@
+export {};
+
+// iterative approach
+function factorialIterative(number: number): number | undefined {
+  if (number < 0) {
+    return undefined;
+  }
+  let total = 1;
+  for (let n = number; n > 1; n--) {
+    total *= n;
+  }
+  return total;
+}
+
+console.log('5! =', factorialIterative(5)); // 5! = 120
+
+// recursive approach
+function factorial(number: number): number | undefined {
+  if (number < 0) { return undefined; }
+  if (number === 1 || number === 0) { // base case
+    return 1;
+  }
+  return number * (factorial(number - 1) ?? 1);
+}
+
+console.log('Recursive 5! =', factorial(5)); // Recursive 5! = 120
+
+// to see the output of this file use the command: node src/09-recursion/02-factorial.ts

src/09-recursion/04-fibonacci.ts

@@ -0,0 +1,54 @@
+export {};
+
+// iterative approach
+function fibonacciIterative(n: number): number {
+  if (n < 0) {
+    throw new Error('Input must be a non-negative integer');
+  }
+  if (n < 2) { return n; }
+
+  let prevPrev = 0;
+  let prev = 1;
+  let current = 0;
+
+  for (let i = 2; i <= n; i++) { // n >= 2
+    current = prev + prevPrev; // f(n-1) + f(n-2)
+    prevPrev = prev;
+    prev = current;
+  }
+
+  return current;
+}
+
+console.log('fibonacciIterative(2)', fibonacciIterative(2)); // 1
+console.log('fibonacciIterative(3)', fibonacciIterative(3)); // 2
+console.log('fibonacciIterative(4)', fibonacciIterative(4)); // 3
+console.log('fibonacciIterative(5)', fibonacciIterative(5)); // 5
+
+// recursive approach
+function fibonacci(n: number): number {
+  if (n < 0) {
+    throw new Error('Input must be a non-negative integer');
+  }
+  if (n < 2) { return n; } // base case
+  return fibonacci(n - 1) + fibonacci(n - 2); // recursive case
+}
+
+console.log('fibonacci(5)', fibonacci(5)); // 5
+
+// memoization approach
+function fibonacciMemoization(n: number): number {
+  if (n < 0) {
+    throw new Error('Input must be a non-negative integer');
+  }
+  const memo: number[] = [0, 1];
+  const fibonacci = (n: number): number => {
+    if (memo[n] != null) return memo[n]!;
+    return (memo[n] = fibonacci(n - 1) + fibonacci(n - 2));
+  };
+  return fibonacci(n);
+}
+
+console.log('fibonacciMemoization(5)', fibonacciMemoization(5)); // 5
+
+// to see the output of this file use the command: node src/09-recursion/04-fibonacci.ts

src/10-tree/01-bst.ts

@@ -0,0 +1,44 @@
+// src/10-tree/01-bst.ts
+import BinarySearchTree from './binary-search-tree';
+
+class Student {
+  idNumber: number;
+  name: string;
+  gradeLevel: number;
+
+  constructor(idNumber: number, name: string, gradeLevel: number, address?: string) {
+    this.idNumber = idNumber;
+    this.name = name;
+    this.gradeLevel = gradeLevel;
+  }
+}
+
+// create student comparator to compare idNumber
+const studentComparator = (a: Student, b: Student) => a.idNumber - b.idNumber;
+
+const studentTree = new BinarySearchTree(studentComparator);
+
+studentTree.insert(new Student(11, 'Darcy', 10));
+studentTree.insert(new Student(7, 'Tory', 10));
+studentTree.insert(new Student(5, 'Caleb', 10));
+studentTree.insert(new Student(9, 'Sofia', 10));
+studentTree.insert(new Student(15, 'Max', 10));
+
+//     11
+//    / \
+//   7   15
+//  / \   
+// 5   9
+
+studentTree.insert(new Student(12, 'Seth', 10));
+
+//    11
+//    / \
+//   7   15
+//  / \  /
+// 5   9 12
+
+
+// to see the output of this file use the command: node src/10-tree/01-bst.js
+
+export {};