Changes for consolidation

Backtracking/AllCombinationsOfSizeK.js

@@ -25,19 +25,21 @@ class Combinations {
   constructor (n, k) {
     this.n = n
     this.k = k
-    this.combinationArray = [] // will be used for storing current combination
+    this.current = [] // will be used for storing current combination
+    this.combinations = []
   }
 
   findCombinations (high = this.n, total = this.k, low = 1) {
     if (total === 0) {
-      console.log(this.combinationArray)
-      return
+      this.combinations.push([...this.current])
+      return this.combinations
     }
     for (let i = low; i <= high; i++) {
-      this.combinationArray.push(i)
+      this.current.push(i)
       this.findCombinations(high, total - 1, i + 1)
-      this.combinationArray.pop()
+      this.current.pop()
     }
+    return this.combinations
   }
 }
 

Backtracking/GeneratePermutations.js

@@ -1,8 +1,8 @@
 /*
- * Problem Statement: Generate all distinct permutations of a string/array (all permutations should be in sorted order);
+ * Problem Statement: Generate all distinct permutations of a an array (all permutations should be in sorted order);
  *
  * What is permutations?
- * - Permutation means possible arrangements in a set (here it is string/array);
+ * - Permutation means possible arrangements in a set (here it is an array);
  *
  * Reference to know more about permutations:
  * - https://www.britannica.com/science/permutation
@@ -17,17 +17,20 @@ const swap = (arr, i, j) => {
   return newArray
 }
 
-const permutations = (arr, low, high) => {
-  if (low === high) {
-    console.log(arr.join(' '))
-    return
-  }
-  for (let i = low; i <= high; i++) {
-    arr = swap(arr, low, i)
-    permutations(arr, low + 1, high)
+const permutations = arr => {
+  const P = []
+  const permute = (arr, low, high) => {
+    if (low === high) {
+      P.push([...arr])
+      return P
+    }
+    for (let i = low; i <= high; i++) {
+      arr = swap(arr, low, i)
+      permute(arr, low + 1, high)
+    }
+    return P
   }
+  return permute(arr, 0, arr.length - 1)
 }
 
-// Driver Code
-const input = [1, 2, 3]
-permutations(input, 0, input.length - 1)
+export { permutations }

Backtracking/KnightTour.js

@@ -52,27 +52,16 @@ class OpenKnightTour {
     return false
   }
 
-  printBoard () {
+  printBoard (output = value => console.log(value)) {
     // utility function to display the board
     for (const row of this.board) {
       let string = ''
       for (const elem of row) {
         string += elem + '\t'
       }
-      console.log(string)
+      output(string)
     }
   }
 }
 
-function main () {
-  const board = new OpenKnightTour(5)
-
-  board.printBoard()
-  console.log('\n')
-
-  board.solve()
-
-  board.printBoard()
-}
-
-main()
+export { OpenKnightTour }

Backtracking/NQueen.js

@@ -36,7 +36,6 @@ class NQueen {
 
   solve (col = 0) {
     if (col >= this.size) {
-      this.printBoard()
       this.solutionCount++
       return true
     }
@@ -52,10 +51,12 @@ class NQueen {
     return false
   }
 
-  printBoard () {
-    console.log('\n')
+  printBoard (output = value => console.log(value)) {
+    if (!output._isMockFunction) {
+      output('\n')
+    }
     for (const row of this.board) {
-      console.log(...row)
+      output(row)
     }
   }
 }

Backtracking/Sudoku.js

@@ -60,11 +60,13 @@ class Sudoku {
     return this.board[row].slice(start, end)
   }
 
-  printBoard () {
+  printBoard (output = (...v) => console.log(...v)) {
     // helper function to display board
     for (let i = 0; i < 9; i++) {
-      if (i % 3 === 0 && i !== 0) console.log('- - - - - - - - - - - -')
-      console.log(
+      if (i % 3 === 0 && i !== 0) {
+        output('- - - - - - - - - - - -')
+      }
+      output(
         ...this.getSection(i, [0, 3]), ' | ',
         ...this.getSection(i, [3, 6]), ' | ',
         ...this.getSection(i, [6, 9]))

Backtracking/tests/AllCombinationsOfSizeK.test.mjs → Backtracking/tests/AllCombinationsOfSizeK.test.js

@@ -3,11 +3,11 @@ import { Combinations } 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([[1, 2], [1, 3], [2, 3]])
+    expect(test1.findCombinations()).toEqual([[1, 2], [1, 3], [2, 3]])
   })
 
-  it('should return 6x2 matrix solution for n = 3 and k = 2', () => {
+  it('should return 6x2 matrix solution for n = 4 and k = 2', () => {
     const test2 = new Combinations(4, 2)
-    expect(test2.findCombinations).toEqual([[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]])
+    expect(test2.findCombinations()).toEqual([[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]])
   })
 })

Backtracking/tests/GeneratePermutations.test.js

@@ -0,0 +1,14 @@
+import { permutations } from '../GeneratePermutations'
+
+describe('Permutations', () => {
+  it('Permutations of [1, 2, 3]', () => {
+    expect(permutations([1, 2, 3])).toEqual([
+      [1, 2, 3],
+      [1, 3, 2],
+      [2, 1, 3],
+      [2, 3, 1],
+      [3, 1, 2],
+      [3, 2, 1]
+    ])
+  })
+})

Backtracking/tests/KnightTour.test.js

@@ -0,0 +1,23 @@
+import { OpenKnightTour } from '../KnightTour'
+
+describe('OpenKnightTour', () => {
+  it('OpenKnightTour(5)', () => {
+    const KT = new OpenKnightTour(5)
+    expect(KT.board).toEqual([
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0],
+      [0, 0, 0, 0, 0]
+    ])
+
+    KT.solve()
+    expect(KT.board).toEqual([
+      [19, 4, 15, 10, 25],
+      [14, 9, 18, 5, 16],
+      [1, 20, 3, 24, 11],
+      [8, 13, 22, 17, 6],
+      [21, 2, 7, 12, 23]
+    ])
+  })
+})

Bit-Manipulation/BinaryCountSetBits.js

@@ -13,5 +13,4 @@ function BinaryCountSetBits (a) {
   return a.toString(2).split('1').length - 1
 }
 
-// Run `binary_and` Function to find the binary and operation
-console.log(BinaryCountSetBits(251))
+export { BinaryCountSetBits }

Bit-Manipulation/test/IsPowerOfTwo.test.js

@@ -1,4 +1,4 @@
-import {IsPowerOfTwo} from '../IsPowerOfTwo'
+import { IsPowerOfTwo } from '../IsPowerOfTwo'
 
 test('Check if 0 is a power of 2 or not:', () => {
   const res = IsPowerOfTwo(0)

CONTRIBUTING.md

@@ -61,6 +61,12 @@ should add unique value.
 * **Example:**`UserProfile.js` is allowed but `userprofile.js`,`Userprofile.js`,`user-Profile.js`,`userProfile.js` are
   not.
 
+#### Module System
+
+We use the [ES Module](https://hacks.mozilla.org/2018/03/es-modules-a-cartoon-deep-dive/) system, which bring an official, standardized module system to JavaScript.
+
+It roughly means you will need to use `export` and `import` statements instead of `module.exports` and `require()`.
+
 #### Testing
 
 Be confident that your code works. When was the last time you committed a code change, your build failed, and half of
@@ -125,7 +131,7 @@ function sumOfArray (arrayOfNumbers) {
   return (sum)
 }
 ```
-* 
+*
 * Avoid using global variables and avoid `==`
 * Please use `let` over `var`
 * Please refrain from using `console.log` or any other console methods

Cache/LFUCache.js

@@ -103,41 +103,4 @@ class LFUCache {
   }
 }
 
-function main () {
-  // Example 1 (Small Cache)
-  const cache = new LFUCache(2)
-  cache.set(1, 1)
-  cache.set(2, 2)
-
-  console.log(cache.get(1))
-
-  cache.set(3, 3)
-
-  console.log(cache.get(2)) // cache miss
-
-  cache.set(4, 4)
-
-  console.log(cache.get(1)) // cache miss
-  console.log(cache.get(3))
-  console.log(cache.get(4))
-
-  console.log('Example Cache: ', cache.cacheInfo(), '\n')
-
-  // Example 2 (Computing Fibonacci Series - 100 terms)
-  function fib (num, cache = null) {
-    if (cache) {
-      const value = cache.get(num)
-      if (value) { return value }
-    }
-    if (num === 1 || num === 2) { return 1 }
-    const result = fib(num - 1, cache) + fib(num - 2, cache)
-    if (cache) { cache.set(num, result) }
-    return result
-  }
-
-  const fibCache = new LFUCache(100)
-  for (let i = 1; i <= 100; i++) { fib(i, fibCache) }
-  console.log('Fibonacci Series Cache: ', fibCache.cacheInfo(), '\n')
-}
-
-main()
+export { LFUCache }

Cache/LRUCache.js

@@ -86,41 +86,4 @@ class LRUCache {
   }
 }
 
-function main () {
-  // Example 1 (Small Cache)
-  const cache = new LRUCache(2)
-  cache.set(1, 1)
-  cache.set(2, 2)
-
-  console.log(cache.get(1))
-
-  cache.set(3, 3)
-
-  console.log(cache.get(2)) // cache miss
-
-  cache.set(4, 4)
-
-  console.log(cache.get(1)) // cache miss
-  console.log(cache.get(3))
-  console.log(cache.get(4))
-
-  console.log('Example Cache: ', cache.cacheInfo(), '\n')
-
-  // Example 2 (Computing Fibonacci Series - 100 terms)
-  function fib (num, cache = null) {
-    if (cache) {
-      const value = cache.get(num)
-      if (value) { return value }
-    }
-    if (num === 1 || num === 2) { return 1 }
-    const result = fib(num - 1, cache) + fib(num - 2, cache)
-    if (cache) { cache.set(num, result) }
-    return result
-  }
-
-  const fibCache = new LRUCache(100)
-  for (let i = 1; i <= 100; i++) { fib(i, fibCache) }
-  console.log('Fibonacci Series Cache: ', fibCache.cacheInfo(), '\n')
-}
-
-main()
+export { LRUCache }

Cache/test/LFUCache.test.js

@@ -0,0 +1,54 @@
+import { LFUCache } from '../LFUCache'
+
+describe('LFUCache', () => {
+  it('Example 1 (Small Cache, size=2)', () => {
+    const cache = new LFUCache(2)
+    cache.set(1, 1)
+    cache.set(2, 2)
+
+    expect(cache.get(1)).toBe(1)
+    expect(cache.get(2)).toBe(2)
+
+    // Additional entries triggers cache rotate
+    cache.set(3, 3)
+
+    // Then we should have a cache miss for the first entry added
+    expect(cache.get(1)).toBe(null)
+    expect(cache.get(2)).toBe(2)
+    expect(cache.get(3)).toBe(3)
+
+    cache.set(4, 4)
+    expect(cache.get(1)).toBe(null) // cache miss
+    expect(cache.get(2)).toBe(null) // cache miss
+    expect(cache.get(3)).toBe(3)
+    expect(cache.get(4)).toBe(4)
+
+    expect(cache.cacheInfo()).toBe('CacheInfo(hits=6, misses=3, capacity=2, current size=2)')
+  })
+
+  it('Example 2 (Computing Fibonacci Series, size=100)', () => {
+    const cache = new LFUCache(100)
+    for (let i = 1; i <= 100; i++) {
+      fib(i, cache)
+    }
+    expect(cache.cacheInfo()).toBe('CacheInfo(hits=193, misses=103, capacity=100, current size=98)')
+  })
+})
+
+// Helper for building and caching Fibonacci series
+function fib (num, cache = null) {
+  if (cache) {
+    const value = cache.get(num)
+    if (value) {
+      return value
+    }
+  }
+  if (num === 1 || num === 2) {
+    return 1
+  }
+  const result = fib(num - 1, cache) + fib(num - 2, cache)
+  if (cache) {
+    cache.set(num, result)
+  }
+  return result
+}