Merge branch 'master' of https://github.com/Akshay73c/JavaScript-algos into LLupdates

Author: AkshayChavan

.github/workflows/Ci.yml

@@ -25,7 +25,7 @@ jobs:
         run: npm run test
 
       - name: 💄 Code style
-        run: npm run style
+        run: npm run check-style
 
   codespell:
     name: Check for spelling errors

Backtracking/AllCombinationsOfSizeK.js

@@ -1,46 +1,28 @@
-/*
-  Problem: Given two numbers, n and k, make all unique combinations of k numbers from 1 to n and in sorted order
-
-  What is combinations?
-  - Combinations is selecting items from a collections without considering the order of selection
-
-  Example:
-  - We have an apple, a banana, and a jackfruit
-  - We have three objects, and need to choose two items, then combinations will be
-
-  1. Apple & Banana
-  2. Apple & Jackfruit
-  3. Banana & Jackfruit
-
-  To read more about combinations, you can visit the following link:
-  - https://betterexplained.com/articles/easy-permutations-and-combinations/
-
-  Solution:
-  - We will be using backtracking to solve this questions
-  - Take one element, and make all them combinations for k-1 elements
-  - Once we get all combinations of that element, pop it and do same for next element
-*/
-
-class Combinations {
-  constructor(n, k) {
-    this.n = n
-    this.k = k
-    this.current = [] // will be used for storing current combination
-    this.combinations = []
-  }
-
-  findCombinations(high = this.n, total = this.k, low = 1) {
-    if (total === 0) {
-      this.combinations.push([...this.current])
-      return this.combinations
+function generateCombinations(n, k) {
+  let currentCombination = []
+  let allCombinations = [] // will be used for storing all combinations
+  let currentValue = 1
+
+  function findCombinations() {
+    if (currentCombination.length === k) {
+      // Add the array of size k to the allCombinations array
+      allCombinations.push([...currentCombination])
+      return
     }
-    for (let i = low; i <= high; i++) {
-      this.current.push(i)
-      this.findCombinations(high, total - 1, i + 1)
-      this.current.pop()
+    if (currentValue > n) {
+      // Check for exceeding the range
+      return
     }
-    return this.combinations
+    currentCombination.push(currentValue++)
+    findCombinations()
+    currentCombination.pop()
+    findCombinations()
+    currentValue--
   }
+
+  findCombinations()
+
+  return allCombinations
 }
 
-export { Combinations }
+export { generateCombinations }

Backtracking/KnightTour.js

@@ -2,12 +2,13 @@
 
 class OpenKnightTour {
   constructor(size) {
+    // Constructor to initialize the chessboard and size
     this.board = new Array(size).fill(0).map(() => new Array(size).fill(0))
     this.size = size
   }
 
   getMoves([i, j]) {
-    // helper function to get the valid moves of the knight from the current position
+    // Helper function to get the valid moves of the knight from the current position
     const moves = [
       [i + 2, j - 1],
       [i + 2, j + 1],
@@ -19,18 +20,19 @@ class OpenKnightTour {
       [i - 1, j + 2]
     ]
 
+    // Filter out moves that are within the board boundaries
     return moves.filter(
       ([y, x]) => y >= 0 && y < this.size && x >= 0 && x < this.size
     )
   }
 
   isComplete() {
-    // helper function to check if the board is complete
+    // Helper function to check if the board is complete
     return !this.board.map((row) => row.includes(0)).includes(true)
   }
 
   solve() {
-    // function to find the solution for the given board
+    // Function to find the solution for the given board
     for (let i = 0; i < this.size; i++) {
       for (let j = 0; j < this.size; j++) {
         if (this.solveHelper([i, j], 0)) return true
@@ -40,22 +42,23 @@ class OpenKnightTour {
   }
 
   solveHelper([i, j], curr) {
-    // helper function for the main computation
+    // Helper function for the main computation
     if (this.isComplete()) return true
 
+    // Iterate through possible moves and attempt to fill the board
     for (const [y, x] of this.getMoves([i, j])) {
       if (this.board[y][x] === 0) {
         this.board[y][x] = curr + 1
         if (this.solveHelper([y, x], curr + 1)) return true
-        // backtracking
+        // Backtracking: If the solution is not found, reset the cell to 0
         this.board[y][x] = 0
       }
     }
     return false
   }
 
   printBoard(output = (value) => console.log(value)) {
-    // utility function to display the board
+    // Utility function to display the board
     for (const row of this.board) {
       let string = ''
       for (const elem of row) {

Backtracking/MColoringProblem.js

@@ -0,0 +1,49 @@
+/**
+ * Colors a graph using up to m colors such that no two adjacent vertices share the same color.
+ * @param {number[][]} graph - Adjacency matrix of the graph, using 0 for no edge.
+ * @param {number} m - The number of colors to use.
+ * @returns {?Array.<number>} A valid M-coloring of the graph using colors 1 to m, or null if none exists.
+ * @see https://en.wikipedia.org/wiki/Graph_coloring
+ */
+function mColoring(graph, m) {
+  const colors = new Array(graph.length).fill(0)
+
+  // Check if it's safe to color a vertex with a given color.
+  function isSafe(vertex, color) {
+    for (let i = 0; i < graph.length; i++) {
+      if (graph[vertex][i] && colors[i] === color) {
+        return false
+      }
+    }
+    return true
+  }
+
+  // Use backtracking to try and color the graph.
+  function solveColoring(vertex = 0) {
+    if (vertex === graph.length) {
+      return true
+    }
+
+    for (let color = 1; color <= m; color++) {
+      if (isSafe(vertex, color)) {
+        colors[vertex] = color
+
+        if (solveColoring(vertex + 1)) {
+          return true
+        }
+
+        // If no solution, backtrack.
+        colors[vertex] = 0
+      }
+    }
+    return false
+  }
+
+  // If coloring is possible, return the colors.
+  if (solveColoring()) {
+    return colors
+  }
+  return null
+}
+
+export { mColoring }

Backtracking/tests/AllCombinationsOfSizeK.test.js

@@ -1,18 +1,18 @@
-import { Combinations } from '../AllCombinationsOfSizeK'
+import { generateCombinations } from '../AllCombinationsOfSizeK'
 
 describe('AllCombinationsOfSizeK', () => {
   it('should return 3x2 matrix solution for n = 3 and k = 2', () => {
-    const test1 = new Combinations(3, 2)
-    expect(test1.findCombinations()).toEqual([
+    const res = generateCombinations(3, 2)
+    expect(res).toEqual([
       [1, 2],
       [1, 3],
       [2, 3]
     ])
   })
 
   it('should return 6x2 matrix solution for n = 4 and k = 2', () => {
-    const test2 = new Combinations(4, 2)
-    expect(test2.findCombinations()).toEqual([
+    const res = generateCombinations(4, 2)
+    expect(res).toEqual([
       [1, 2],
       [1, 3],
       [1, 4],

Backtracking/tests/MColoringProblem.test.js

@@ -0,0 +1,23 @@
+import { mColoring } from '../MColoringProblem'
+
+describe('MColoringProblem', () => {
+  it('should color a triangle with 3 colors', () => {
+    const graph = [
+      [0, 1, 1],
+      [1, 0, 1],
+      [1, 1, 0]
+    ]
+    const solution = mColoring(graph, 3)
+    expect(solution).not.toBeNull()
+  })
+
+  it('should not color a triangle with 2 colors', () => {
+    const graph = [
+      [0, 1, 1],
+      [1, 0, 1],
+      [1, 1, 0]
+    ]
+    const solution = mColoring(graph, 2)
+    expect(solution).toBeNull()
+  })
+})

Bit-Manipulation/BinaryCountSetBits.js

@@ -14,8 +14,13 @@ function BinaryCountSetBits(a) {
 
   if (!Number.isInteger(a)) throw new TypeError('Argument not an Integer')
 
-  // convert number into binary representation and return number of set bits in binary representation
-  return a.toString(2).split('1').length - 1
+  let count = 0
+  while (a) {
+    a &= a - 1
+    count++
+  }
+
+  return count
 }
 
 export { BinaryCountSetBits }

Bit-Manipulation/GenerateSubSets.js

@@ -0,0 +1,34 @@
+/**
+ * @function generateSubSets
+ * @param {Array} inputArray
+ * @returns {Array}
+ * @example [1,2] -> [[],[1],[2],[1,2]]
+ */
+
+// The time complexity of this algorithm is BigO(2^n) where n is the length of array
+function generateSubSets(inputArray) {
+  if (!Array.isArray(inputArray)) {
+    throw new Error('Provided input is not an array')
+  }
+  if (inputArray.length > 32) {
+    throw new RangeError('Error size should be less than equal to 32')
+  }
+  let arrayLength = inputArray.length
+  let subSets = []
+  // loop till (2^n) - 1
+  for (let i = 0; i < 1 << arrayLength; i++) {
+    let subSet = []
+    for (let j = 0; j < arrayLength; j++) {
+      // 1 << j it shifts binary digit 1 by j positions and then we perform
+      // and by AND operation we are checking whetheer jth bit
+      // in i is set to 1 if result is non zero just add into set
+      if (i & (1 << j)) {
+        subSet.push(inputArray[j])
+      }
+    }
+    subSets.push(subSet)
+  }
+  return subSets
+}
+
+export { generateSubSets }

Bit-Manipulation/test/GenerateSubSets.test.js

@@ -0,0 +1,36 @@
+import { generateSubSets } from '../GenerateSubSets'
+
+describe('subSets', () => {
+  it('find the subsets', () => {
+    expect(generateSubSets([1, 2, 3])).toEqual([
+      [],
+      [1],
+      [2],
+      [1, 2],
+      [3],
+      [1, 3],
+      [2, 3],
+      [1, 2, 3]
+    ])
+    expect(generateSubSets([1, 2])).toEqual([[], [1], [2], [1, 2]])
+    expect(generateSubSets([1, 2, 3])).toEqual([
+      [],
+      [1],
+      [2],
+      [1, 2],
+      [3],
+      [1, 3],
+      [2, 3],
+      [1, 2, 3]
+    ])
+    expect(() => generateSubSets('invalid')).toThrow(
+      'Provided input is not an array'
+    )
+    expect(() =>
+      generateSubSets([
+        1, 2, 2, 1, 2, 3, 4, 3, 2, 3, 4, 3, 2, 2, 2, 3, 12, 11, 4, 2, 2, 2, 2,
+        1, 2, 3, 5, 6, 7, 7, 8, 6, 5, 6, 7, 8, 9, 8, 0, 6
+      ])
+    ).toThrow('Error size should be less than equal to 32')
+  })
+})

CONTRIBUTING.md

@@ -125,7 +125,7 @@ npm test -- koch
 You can also start Vitest in "watch" mode:
 
 ```bash
-npm test-watch
+npm run test-watch
 ```
 
 This will run all tests and watch source and test files for changes. When a change is made, the tests will run again.

DIRECTORY.md

@@ -3,12 +3,14 @@
   * [generateParentheses](Backtracking/generateParentheses.js)
   * [GeneratePermutations](Backtracking/GeneratePermutations.js)
   * [KnightTour](Backtracking/KnightTour.js)
+  * [MColoringProblem](Backtracking/MColoringProblem.js)
   * [NQueens](Backtracking/NQueens.js)
   * [RatInAMaze](Backtracking/RatInAMaze.js)
   * [Sudoku](Backtracking/Sudoku.js)
   * [SumOfSubset](Backtracking/SumOfSubset.js)
 * **Bit-Manipulation**
   * [BinaryCountSetBits](Bit-Manipulation/BinaryCountSetBits.js)
+  * [GenerateSubSets](Bit-Manipulation/GenerateSubSets.js)
   * [GrayCodes](Bit-Manipulation/GrayCodes.js)
   * [IsPowerofFour](Bit-Manipulation/IsPowerofFour.js)
   * [IsPowerOfTwo](Bit-Manipulation/IsPowerOfTwo.js)
@@ -159,6 +161,7 @@
   * [NumberOfIslands](Graphs/NumberOfIslands.js)
   * [PrimMST](Graphs/PrimMST.js)
 * **Hashes**
+  * [MD5](Hashes/MD5.js)
   * [SHA1](Hashes/SHA1.js)
   * [SHA256](Hashes/SHA256.js)
 * **Maths**
@@ -167,6 +170,7 @@
   * [Area](Maths/Area.js)
   * [ArithmeticGeometricMean](Maths/ArithmeticGeometricMean.js)
   * [ArmstrongNumber](Maths/ArmstrongNumber.js)
+  * [AutomorphicNumber](Maths/AutomorphicNumber.js)
   * [AverageMean](Maths/AverageMean.js)
   * [AverageMedian](Maths/AverageMedian.js)
   * [BinaryConvert](Maths/BinaryConvert.js)
@@ -298,6 +302,7 @@
   * [KochSnowflake](Recursive/KochSnowflake.js)
   * [LetterCombination](Recursive/LetterCombination.js)
   * [Palindrome](Recursive/Palindrome.js)
+  * [Partition](Recursive/Partition.js)
   * [SubsequenceRecursive](Recursive/SubsequenceRecursive.js)
   * [TowerOfHanoi](Recursive/TowerOfHanoi.js)
 * **Search**
@@ -309,6 +314,7 @@
   * [LinearSearch](Search/LinearSearch.js)
   * [Minesweeper](Search/Minesweeper.js)
   * [QuickSelectSearch](Search/QuickSelectSearch.js)
+  * [RabinKarp](Search/RabinKarp.js)
   * [SlidingWindow](Search/SlidingWindow.js)
   * [StringSearch](Search/StringSearch.js)
   * [TernarySearch](Search/TernarySearch.js)

Data-Structures/Heap/test/BinaryHeap.test.js

@@ -36,7 +36,6 @@ describe('BinaryHeap', () => {
     it('should handle insertion of duplicate values', () => {
       // Check if the heap handles duplicate values correctly
       minHeap.insert(2)
-      console.log(minHeap.heap)
       expect(minHeap.heap).toEqual([1, 3, 2, 4, 8, 6, 2])
     })