Merge branch 'master' into master

Author: christian4423

README.md

@@ -38,6 +38,7 @@ the data.
     * `A` [Fenwick Tree](src/data-structures/tree/fenwick-tree) (Binary Indexed Tree)
 * `A` [Graph](src/data-structures/graph) (both directed and undirected)
 * `A` [Disjoint Set](src/data-structures/disjoint-set)
+* `A` [Bloom Filter](src/data-structures/bloom-filter)
 
 ## Algorithms
 
@@ -70,6 +71,7 @@ a set of rules that precisely define a sequence of operations.
   * `A` [Shortest Common Supersequence](src/algorithms/sets/shortest-common-supersequence) (SCS)
   * `A` [Knapsack Problem](src/algorithms/sets/knapsack-problem) - "0/1" and "Unbound" ones
   * `A` [Maximum Subarray](src/algorithms/sets/maximum-subarray) - "Brute Force" and "Dynamic Programming" (Kadane's) versions
+  * `A` [Combination Sum](src/algorithms/sets/combination-sum) - find all combinations that form specific sum
 * **Strings**
   * `A` [Levenshtein Distance](src/algorithms/string/levenshtein-distance) - minimum edit distance between two sequences
   * `B` [Hamming Distance](src/algorithms/string/hamming-distance) - number of positions at which the symbols are different
@@ -160,6 +162,7 @@ different path of finding a solution. Normally the DFS traversal of state-space
   * `A` [Hamiltonian Cycle](src/algorithms/graph/hamiltonian-cycle) - Visit every vertex exactly once
   * `A` [N-Queens Problem](src/algorithms/uncategorized/n-queens)
   * `A` [Knight's Tour](src/algorithms/uncategorized/knight-tour)
+  * `A` [Combination Sum](src/algorithms/sets/combination-sum) - find all combinations that form specific sum
 * **Branch & Bound** - remember the lowest-cost solution found at each stage of the backtracking
 search, and use the cost of the lowest-cost solution found so far as a lower bound on the cost of
 a least-cost solution to the problem, in order to discard partial solutions with costs larger than the
@@ -233,6 +236,7 @@ Below is the list of some of the most used Big O notations and their performance
 | **B-Tree**              | log(n)    | log(n)    | log(n)    | log(n)    |           |
 | **Red-Black Tree**      | log(n)    | log(n)    | log(n)    | log(n)    |           |
 | **AVL Tree**            | log(n)    | log(n)    | log(n)    | log(n)    |           |
+| **Bloom Filter**        | -         | 1         | 1         | -         | False positives are possible while searching |
 
 ### Array Sorting Algorithms Complexity
 

src/algorithms/sets/combination-sum/README.md

@@ -0,0 +1,60 @@
+# Combination Sum Problem
+
+Given a **set** of candidate numbers (`candidates`) **(without duplicates)** and 
+a target number (`target`), find all unique combinations in `candidates` where 
+the candidate numbers sums to `target`.
+
+The **same** repeated number may be chosen from `candidates` unlimited number 
+of times.
+
+**Note:**
+
+- All numbers (including `target`) will be positive integers.
+- The solution set must not contain duplicate combinations.
+
+## Examples
+
+```
+Input: candidates = [2,3,6,7], target = 7,
+
+A solution set is:
+[
+  [7],
+  [2,2,3]
+]
+```
+
+```
+Input: candidates = [2,3,5], target = 8,
+
+A solution set is:
+[
+  [2,2,2,2],
+  [2,3,3],
+  [3,5]
+]
+```
+
+## Explanations
+
+Since the problem is to get all the possible results, not the best or the 
+number of result, thus we don’t need to consider DP (dynamic programming),
+backtracking approach using recursion is needed to handle it.
+
+Here is an example of decision tree for the situation when `candidates = [2, 3]` and `target = 6`:
+
+```
+                0
+              /   \
+           +2      +3
+          /   \      \
+       +2       +3    +3
+      /  \     /  \     \
+    +2    ✘   ✘   ✘     ✓
+   /  \
+  ✓    ✘    
+```
+
+## References
+
+- [LeetCode](https://leetcode.com/problems/combination-sum/description/)

src/algorithms/sets/combination-sum/__test__/combinationSum.test.js

@@ -0,0 +1,24 @@
+import combinationSum from '../combinationSum';
+
+describe('combinationSum', () => {
+  it('should find all combinations with specific sum', () => {
+    expect(combinationSum([1], 4)).toEqual([
+      [1, 1, 1, 1],
+    ]);
+
+    expect(combinationSum([2, 3, 6, 7], 7)).toEqual([
+      [2, 2, 3],
+      [7],
+    ]);
+
+    expect(combinationSum([2, 3, 5], 8)).toEqual([
+      [2, 2, 2, 2],
+      [2, 3, 3],
+      [3, 5],
+    ]);
+
+    expect(combinationSum([2, 5], 3)).toEqual([]);
+
+    expect(combinationSum([], 3)).toEqual([]);
+  });
+});

src/algorithms/sets/combination-sum/combinationSum.js

@@ -0,0 +1,65 @@
+/**
+ * @param {number[]} candidates - candidate numbers we're picking from.
+ * @param {number} remainingSum - remaining sum after adding candidates to currentCombination.
+ * @param {number[][]} finalCombinations - resulting list of combinations.
+ * @param {number[]} currentCombination - currently explored candidates.
+ * @param {number} startFrom - index of the candidate to start further exploration from.
+ * @return {number[][]}
+ */
+function combinationSumRecursive(
+  candidates,
+  remainingSum,
+  finalCombinations = [],
+  currentCombination = [],
+  startFrom = 0,
+) {
+  if (remainingSum < 0) {
+    // By adding another candidate we've gone below zero.
+    // This would mean that last candidate was not acceptable.
+    return finalCombinations;
+  }
+
+  if (remainingSum === 0) {
+    // In case if after adding the previous candidate out remaining sum
+    // became zero we need to same current combination since it is one
+    // of the answer we're looking for.
+    finalCombinations.push(currentCombination.slice());
+
+    return finalCombinations;
+  }
+
+  // In case if we haven't reached zero yet let's continue to add all
+  // possible candidates that are left.
+  for (let candidateIndex = startFrom; candidateIndex < candidates.length; candidateIndex += 1) {
+    const currentCandidate = candidates[candidateIndex];
+
+    // Let's try to add another candidate.
+    currentCombination.push(currentCandidate);
+
+    // Explore further option with current candidate being added.
+    combinationSumRecursive(
+      candidates,
+      remainingSum - currentCandidate,
+      finalCombinations,
+      currentCombination,
+      candidateIndex,
+    );
+
+    // BACKTRACKING.
+    // Let's get back, exclude current candidate and try another ones later.
+    currentCombination.pop();
+  }
+
+  return finalCombinations;
+}
+
+/**
+ * Backtracking algorithm of finding all possible combination for specific sum.
+ *
+ * @param {number[]} candidates
+ * @param {number} target
+ * @return {number[][]}
+ */
+export default function combinationSum(candidates, target) {
+  return combinationSumRecursive(candidates, target);
+}

src/data-structures/bloom-filter/BloomFilter.js

@@ -0,0 +1,131 @@
+export default class BloomFilter {
+  /**
+   * @param {number} size - the size of the storage.
+   */
+  constructor(size = 100) {
+    // Bloom filter size directly affects the likelihood of false positives.
+    // The bigger the size the lower the likelihood of false positives.
+    this.size = size;
+    this.storage = this.createStore(size);
+  }
+
+  /**
+   * @param {string} item
+   */
+  insert(item) {
+    const hashValues = this.getHashValues(item);
+
+    // Set each hashValue index to true.
+    hashValues.forEach(val => this.storage.setValue(val));
+  }
+
+  /**
+   * @param {string} item
+   * @return {boolean}
+   */
+  mayContain(item) {
+    const hashValues = this.getHashValues(item);
+
+    for (let hashIndex = 0; hashIndex < hashValues.length; hashIndex += 1) {
+      if (!this.storage.getValue(hashValues[hashIndex])) {
+        // We know that the item was definitely not inserted.
+        return false;
+      }
+    }
+
+    // The item may or may not have been inserted.
+    return true;
+  }
+
+  /**
+   * Creates the data store for our filter.
+   * We use this method to generate the store in order to
+   * encapsulate the data itself and only provide access
+   * to the necessary methods.
+   *
+   * @param {number} size
+   * @return {Object}
+   */
+  createStore(size) {
+    const storage = [];
+
+    // Initialize all indexes to false
+    for (let storageCellIndex = 0; storageCellIndex < size; storageCellIndex += 1) {
+      storage.push(false);
+    }
+
+    const storageInterface = {
+      getValue(index) {
+        return storage[index];
+      },
+      setValue(index) {
+        storage[index] = true;
+      },
+    };
+
+    return storageInterface;
+  }
+
+  /**
+   * @param {string} item
+   * @return {number}
+   */
+  hash1(item) {
+    let hash = 0;
+
+    for (let charIndex = 0; charIndex < item.length; charIndex += 1) {
+      const char = item.charCodeAt(charIndex);
+      hash = (hash << 5) + hash + char;
+      hash &= hash; // Convert to 32bit integer
+      hash = Math.abs(hash);
+    }
+
+    return hash % this.size;
+  }
+
+  /**
+   * @param {string} item
+   * @return {number}
+   */
+  hash2(item) {
+    let hash = 5381;
+
+    for (let charIndex = 0; charIndex < item.length; charIndex += 1) {
+      const char = item.charCodeAt(charIndex);
+      hash = (hash << 5) + hash + char; /* hash * 33 + c */
+    }
+
+    return Math.abs(hash % this.size);
+  }
+
+  /**
+   * @param {string} item
+   * @return {number}
+   */
+  hash3(item) {
+    let hash = 0;
+
+    for (let charIndex = 0; charIndex < item.length; charIndex += 1) {
+      const char = item.charCodeAt(charIndex);
+      hash = (hash << 5) - hash;
+      hash += char;
+      hash &= hash; // Convert to 32bit integer
+    }
+
+    return Math.abs(hash % this.size);
+  }
+
+  /**
+   * Runs all 3 hash functions on the input and returns an array of results.
+   *
+   * @param {string} item
+   * @return {number[]}
+   */
+  getHashValues(item) {
+    return [
+      this.hash1(item),
+      this.hash2(item),
+      this.hash3(item),
+    ];
+  }
+}