Merge branch 'master' into add-double-factorial

Author: appgurueu

.github/workflows/upload_coverage_report.yml

@@ -0,0 +1,32 @@
+---
+name: upload_coverage_report
+
+'on':
+  workflow_dispatch:
+  push:
+    branches:
+      - master
+  pull_request:
+
+jobs:
+  upload_coverage_report:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: "18.x"
+
+      - name: Install dependencies
+        run: npm ci
+
+      - name: Generate coverage report
+        run: npm test -- --coverage
+
+      - name: Upload coverage to codecov
+        uses: codecov/codecov-action@v3
+        with:
+          files: "coverage/coverage-final.json"
+          fail_ci_if_error: true
+...

.gitignore

@@ -14,3 +14,5 @@ yarn-error.log*
 
 # intelliJ workspace folder
 .idea
+
+/coverage

.gitpod.yml

@@ -0,0 +1,5 @@
+tasks:
+  - init: |
+      npm install && npm test
+
+

CONTRIBUTING.md

@@ -63,14 +63,14 @@ should add unique value.
 #### Commit Messages Formatting
 
 - Prefer to use the [Conventional Commits](https://www.conventionalcommits.org/) format: `<type>: <short summary>`. If necessary, put any extra information in the description.
-- Commit types include (but are not limited to): 
+- Commit types include (but are not limited to):
   - **docs**: Documentation only changes
   - **feat**: A new feature
   - **fix**: A bug fix
   - **test**: Adding or fixing tests
   - **chore**: CI / code quality / minor quality of life improvements
 
-- **Examples**: 
+- **Examples**:
   - `feat: add quicksort algorithm`
   - `chore: fix spelling`
   - `fix: improper error message`

DIRECTORY.md

@@ -7,10 +7,12 @@
     * [Generateparentheses.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/backtracking/test/generateparentheses.test.ts)
 
 ## Bit Manipulation
+  * [Add Binary](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/bit_manipulation/add_binary.ts)
   * [Is Power Of 2](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/bit_manipulation/is_power_of_2.ts)
   * [Is Power Of 4](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/bit_manipulation/is_power_of_4.ts)
   * [Log Two](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/bit_manipulation/log_two.ts)
   * Test
+    * [Add Binary.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/bit_manipulation/test/add_binary.test.ts)
     * [Is Power Of 2.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/bit_manipulation/test/is_power_of_2.test.ts)
     * [Is Power Of 4.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/bit_manipulation/test/is_power_of_4.test.ts)
     * [Log Two.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/bit_manipulation/test/log_two.test.ts)
@@ -26,8 +28,7 @@
   * Heap
     * [Heap](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/data_structures/heap/heap.ts)
     * Test
-      * [Max Heap.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/data_structures/heap/test/max_heap.test.ts)
-      * [Min Heap.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/data_structures/heap/test/min_heap.test.ts)
+      * [Heap.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/data_structures/heap/test/heap.test.ts)
   * List
     * [Doubly Linked List](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/data_structures/list/doubly_linked_list.ts)
     * [Linked List](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/data_structures/list/linked_list.ts)
@@ -72,23 +73,30 @@
     * [Tries](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/data_structures/tries/tries.ts)
 
 ## Dynamic Programming
+  * [Coin Change](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/dynamic_programming/coin_change.ts)
   * [Knapsack](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/dynamic_programming/knapsack.ts)
   * [Lcs](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/dynamic_programming/lcs.ts)
 
 ## Graph
   * [Bellman Ford](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/bellman_ford.ts)
+  * [Bipartite Graph](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/bipartite_graph.ts)
   * [Dijkstra](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/dijkstra.ts)
   * [Floyd Warshall](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/floyd_warshall.ts)
   * [Johnson](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/johnson.ts)
+  * [Kosajaru](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/kosajaru.ts)
   * [Kruskal](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/kruskal.ts)
   * [Prim](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/prim.ts)
+  * [Tarjan](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/tarjan.ts)
   * Test
     * [Bellman Ford.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/test/bellman_ford.test.ts)
+    * [Bipartite Graph.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/test/bipartite_graph.test.ts)
     * [Dijkstra.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/test/dijkstra.test.ts)
     * [Floyd Warshall.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/test/floyd_warshall.test.ts)
     * [Johnson.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/test/johnson.test.ts)
+    * [Kosajaru.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/test/kosajaru.test.ts)
     * [Kruskal.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/test/kruskal.test.ts)
     * [Prim.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/test/prim.test.ts)
+    * [Tarjan.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/graph/test/tarjan.test.ts)
 
 ## Maths
   * [Absolute Value](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/absolute_value.ts)
@@ -101,10 +109,12 @@
   * [Degrees To Radians](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/degrees_to_radians.ts)
   * [Digit Sum](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/digit_sum.ts)
   * [Double Factorial Iterative](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/double_factorial_iterative.ts)
+  * [Euler Totient](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/euler_totient.ts)
   * [Factorial](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/factorial.ts)
   * [Factors](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/factors.ts)
   * [Fibonacci](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/fibonacci.ts)
   * [Find Min](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/find_min.ts)
+  * [Gaussian Elimination](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/gaussian_elimination.ts)
   * [Greatest Common Factor](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/greatest_common_factor.ts)
   * [Hamming Distance](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/hamming_distance.ts)
   * [Is Divisible](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/is_divisible.ts)
@@ -115,10 +125,12 @@
   * [Is Square Free](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/is_square_free.ts)
   * [Juggler Sequence](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/juggler_sequence.ts)
   * [Lowest Common Multiple](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/lowest_common_multiple.ts)
+  * [Matrix Multiplication](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/matrix_multiplication.ts)
   * [Number Of Digits](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/number_of_digits.ts)
   * [Pascals Triangle](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/pascals_triangle.ts)
   * [Perfect Cube](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/perfect_cube.ts)
   * [Perfect Square](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/perfect_square.ts)
+  * [Prime Factorization](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/prime_factorization.ts)
   * [Primes](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/primes.ts)
   * [Pronic Number](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/pronic_number.ts)
   * [Radians To Degrees](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/radians_to_degrees.ts)
@@ -128,6 +140,7 @@
       * [Hexagonal Numbers.Test](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/series/test/hexagonal_numbers.test.ts)
   * [Sieve Of Eratosthenes](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/sieve_of_eratosthenes.ts)
   * [Signum](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/signum.ts)
+  * [Square Root](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/square_root.ts)
   * [Ugly Numbers](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/ugly_numbers.ts)
   * [Zellers Congruence](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/maths/zellers_congruence.ts)
 
@@ -142,6 +155,7 @@
 
 ## Search
   * [Binary Search](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/search/binary_search.ts)
+  * [Interpolation Search](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/search/interpolation_search.ts)
   * [Jump Search](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/search/jump_search.ts)
   * [Linear Search](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/search/linear_search.ts)
   * [Sentinel Search](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/search/sentinel_search.ts)
@@ -152,10 +166,12 @@
   * [Counting Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/counting_sort.ts)
   * [Cycle Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/cycle_sort.ts)
   * [Gnome Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/gnome_sort.ts)
+  * [Heap Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/heap_sort.ts)
   * [Insertion Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/insertion_sort.ts)
   * [Merge Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/merge_sort.ts)
   * [Quick Select](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/quick_select.ts)
   * [Quick Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/quick_sort.ts)
   * [Selection Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/selection_sort.ts)
   * [Shell Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/shell_sort.ts)
   * [Swap Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/swap_sort.ts)
+  * [Tree Sort](https://github.com/TheAlgorithms/TypeScript/blob/HEAD/sorts/tree_sort.ts)

README.md

@@ -9,8 +9,9 @@ TypeScript Repository of TheAlgorithms, which implements various algorithms and
 
   [![Contributions Welcome][welcome]](CONTRIBUTING.md)
   [![Discord chat][chat]][discord-server]
-
-  
+  <a href="https://gitpod.io/#https://github.com/TheAlgorithms/TypeScript">
+    <img src="https://img.shields.io/badge/Gitpod-Ready--to--Code-blue?logo=gitpod&style=flat-square" height="20" alt="Gitpod Ready-to-Code">
+  </a>
 </div>
 
 ---

backtracking/all_combinations_of_size_k.ts

@@ -10,8 +10,8 @@
  *   and repeat the same process for the next number.
  */
 export function generateCombinations(n: number, k: number): number[][] {
-  let combinationsAcc: number[][] = [];
-  let currentCombination: number[] = [];
+  const combinationsAcc: number[][] = [];
+  const currentCombination: number[] = [];
 
   function generateAllCombos(
     n: number,

bit_manipulation/add_binary.ts

@@ -0,0 +1,27 @@
+/**
+ * Adds two binary strings and returns the result as a binary string.
+ *
+ * @param firstBinaryNo - The first binary string.
+ * @param secondBinaryNo - The second binary string.
+ * @returns The binary sum of the input strings.
+ */
+export function addBinary(firstBinaryNo: string, secondBinaryNo: string): string {
+    let lengthOfFirstNumber: number = firstBinaryNo.length - 1;
+    let lengthOfSecondNumber: number = secondBinaryNo.length - 1;
+    const solution: string[] = [];
+    let carry: number = 0;
+
+    while ( lengthOfFirstNumber >= 0 || lengthOfSecondNumber >= 0) {
+        let sum: number = carry;
+        if (lengthOfFirstNumber >= 0) sum += parseInt(firstBinaryNo.charAt(lengthOfFirstNumber));
+        if (lengthOfSecondNumber >= 0) sum += parseInt(secondBinaryNo.charAt(lengthOfSecondNumber));
+        solution.push((sum % 2).toString());
+        carry = Math.floor(sum / 2);
+        lengthOfFirstNumber--;
+        lengthOfSecondNumber--;
+    }
+
+    if (carry !== 0) solution.push(carry.toString());
+
+    return solution.reverse().join('');
+}

bit_manipulation/test/add_binary.test.ts

@@ -0,0 +1,33 @@
+import { addBinary } from "../add_binary";
+
+describe('Add Binary Number', () => {
+    it('should add two binary numbers with no carry', () => {
+        const result = addBinary('1101', '1011');
+        expect(result).toBe('11000');
+    });
+
+    it('should add two binary numbers with carry', () => {
+        const result = addBinary('1111', '1111');
+        expect(result).toBe('11110');
+    });
+
+    it('should add two different-length binary numbers', () => {
+        const result = addBinary('1101', '111');
+        expect(result).toBe('10100');
+    });
+
+    it('should add two empty binary numbers', () => {
+        const result = addBinary('', '');
+        expect(result).toBe('');
+    });
+
+    it('should add one empty binary number to a non-empty number', () => {
+        const result = addBinary('1010', '');
+        expect(result).toBe('1010');
+    });
+
+    it('should add one non-empty binary number to an empty number', () => {
+        const result = addBinary('', '1101');
+        expect(result).toBe('1101');
+    });
+});

data_structures/heap/heap.ts

@@ -50,7 +50,7 @@ export abstract class Heap<T> {
   }
 
   public extract(): T {
-    let maxElement = this.heap[0];
+    const maxElement = this.heap[0];
     this.heap[0] = this.heap[this.size() - 1];
     this.heap.pop();
     this.sinkDown();
@@ -162,8 +162,8 @@ export class PriorityQueue<T> extends MinHeap<T> {
   }
 
   protected swap(a: number, b: number) {
-    let akey = this.keys_index(this.heap[a]);
-    let bkey = this.keys_index(this.heap[b]);
+    const akey = this.keys_index(this.heap[a]);
+    const bkey = this.keys_index(this.heap[b]);
     [this.keys[akey], this.keys[bkey]] = [this.keys[bkey], this.keys[akey]];
     super.swap(a, b);
   }
@@ -188,7 +188,7 @@ export class PriorityQueue<T> extends MinHeap<T> {
       this.insert(value);
       return;
     }
-    let key = this.keys[idx];
+    const key = this.keys[idx];
     if (this.compare(this.heap[key], value)) {
       // Do not do anything if the value in the heap already has a higher priority.
       return;

data_structures/heap/test/min_heap.test.ts renamed to data_structures/heap/test/heap.test.ts

@@ -1,4 +1,57 @@
-import { MinHeap, PriorityQueue } from "../heap";
+import { MaxHeap, MinHeap, PriorityQueue } from "../heap";
+
+describe("MaxHeap", () => {
+  let heap: MaxHeap<number>;
+  const elements: number[] = [
+    12, 4, 43, 42, 9, 7, 39, 16, 55, 1, 51, 34, 81, 18,
+  ];
+
+  beforeEach(() => {
+    heap = new MaxHeap();
+    for (const element of elements) {
+      heap.insert(element);
+    }
+  });
+
+  it("should initialize a heap from input array", () => {
+    expect(heap.isEmpty()).toEqual(false);
+    heap.check();
+  });
+
+  it("should remove and return the max element in the heap", () => {
+    const maxValue = heap.extract();
+
+    expect(maxValue).toEqual(81);
+    heap.check();
+  });
+
+  it("should insert a new element and bubble Up the element to it correct index in the heap", () => {
+    heap.insert(61);
+    heap.check();
+  });
+
+  const extract_all = (heap: MaxHeap<number>) => {
+    [...elements].sort((a, b) => b - a).forEach((element: number) => {
+      expect(heap.extract()).toEqual(element);
+    });
+    heap.check();
+    expect(heap.size()).toEqual(0);
+  }
+
+  it("should remove and return the max elements in order", () => {
+    extract_all(heap);
+  });
+
+  it("should insert all, then remove and return the max elements in order", () => {
+    heap = new MaxHeap();
+    elements.forEach((element: number) => {
+      heap.insert(element);
+    });
+    heap.check();
+    expect(heap.size()).toEqual(elements.length);
+    extract_all(heap);
+  });
+});
 
 describe("MinHeap", () => {
   let heap: MinHeap<number>;
@@ -8,7 +61,7 @@ describe("MinHeap", () => {
 
   beforeEach(() => {
     heap = new MinHeap();
-    for (let element of elements) {
+    for (const element of elements) {
       heap.insert(element);
     }
   });
@@ -53,7 +106,7 @@ describe("MinHeap", () => {
   });
 
   it("should increase priority", () => {
-    let heap = new PriorityQueue((a: number) => { return a; }, elements.length);
+    const heap = new PriorityQueue((a: number) => { return a; }, elements.length);
     elements.forEach((element: number) => {
       heap.insert(element);
     });