Merge branch 'master' of github.com:knaxus/problem-solving-javascript into problems

Author: ashokdey

Diff for: README.md

@@ -29,6 +29,8 @@ Collection of interview questions with Unit Tests. Problems includes Data Struct
   - [Postfix Expression Evaluation](src/_DataStructures_/Stack/postfix-expression-evaluation)
   - [Remove Consecutive Repeated Digits](src/_DataStructures_/Stack/remove-consecutive-repeated-digits)
   - [Implement 2 Stacks using Single Array](src/_DataStructures_/Stack/2-stacks-using1-array)
+  - [Sort a Stack](src/_DataStructures_/Stack/sort-a-stack)
+
 
 - [Queue](src/_DataStructures_/Queue)
 

Diff for: src/_DataStructures_/Stack/sort-a-stack/index.js

@@ -0,0 +1,36 @@
+/**
+ * Sort a stack with the help of a temporary stack.
+ * Input:[1,10,21,3,9,-11,32]
+ * Output:[32,21,10,9,3,1,-11]
+ * Time Complexity:O(N^2) 
+*/
+const Stack = require('../index');
+
+function sortStack(stack) {
+    const tempStack = new Stack();
+    while (!stack.isEmpty()) {
+        //pop the first element from stack
+        let temp = stack.pop();
+        //for ascending order (tempStack.peek() < temp)
+        while (!tempStack.isEmpty() && tempStack.peek() > temp) {
+            stack.push(tempStack.pop());
+        }
+        //push the first element(temp) onto tempStack if tempStack.peek()<temp
+        tempStack.push(temp);
+    }
+    return tempStack;
+}
+/*
+const s = new Stack();
+
+s.push(1);
+s.push(10);
+s.push(21);
+s.push(3);
+s.push(9);
+s.push(-11);
+s.push(32);
+console.log(s.data);
+const s1 = sortStack(s);
+console.log(s1.data);
+*/

Diff for: src/_DataStructures_/Trees/BinarySearchTree/BinarySearchTree.test.js

@@ -0,0 +1,25 @@
+const BST = require('.');
+
+describe('Data Structure : Binary Search Tree', () => {
+    it('Should be class', () => {
+        expect(typeof BST.prototype.constructor).toEqual('function');
+    });
+
+    describe('Binary Search Tree API', () => {
+        let bst = null;
+
+        beforeEach(() => {
+            bst = new BST(5);
+        });
+
+        it('Should delete() an element from Binary Search Tree', () => {
+            bst.add(4);
+            bst.add(9);
+            bst.add(2);
+            bst.delete(bst.root, 4);
+            expect(bst.traverseInorder()).toEqual([2, 5, 9]);
+            bst.delete(bst.root, 2);
+            expect(bst.traverseInorder()).toEqual([5, 9]);
+        });
+    });
+});

Diff for: src/_DataStructures_/Trees/BinarySearchTree/bst-insertion.test.js

@@ -0,0 +1,68 @@
+const BinarySearchTree = require('./index');
+
+describe('Binary Search Tree', () => {
+  let bst;
+  let rootsLeftChild;
+  let rootsRightChild;
+  let rootsLeftChildsLeftChild;
+  let rootsLeftChildsRightChild;
+  let rootsRightChildsLeftChild;
+  let rootsRightChildsRightChild;
+
+  describe('Creates a binary search tree', () => {
+    it('should create a bst with root 100', () => {
+      bst = new BinarySearchTree(100);
+      expect(bst.root.value).toEqual(100);
+    });
+
+    it('should add element 20 to the left of root node', () => {
+      bst.add(20);
+      rootsLeftChild = bst.root.leftChild;
+      expect(rootsLeftChild.value).toEqual(20);
+    });
+
+    it('should add element 500 to the right of root node', () => {
+      bst.add(500);
+      rootsRightChild = bst.root.rightChild;
+      expect(rootsRightChild.value).toEqual(500);
+    });
+
+    it('should add element 10 to the left of root"s left child', () => {
+      bst.add(10);
+      rootsLeftChildsLeftChild = bst.root.leftChild.leftChild;
+      expect(rootsLeftChildsLeftChild.value).toEqual(10);
+    });
+
+    it('should add element 30 to the right of root"s left child', () => {
+      bst.add(30);
+      rootsLeftChildsRightChild = bst.root.leftChild.rightChild;
+      expect(rootsLeftChildsRightChild.value).toEqual(30);
+    });
+
+    it('should add element 400 to the left of root"s right child', () => {
+      bst.add(400);
+      rootsRightChildsLeftChild = bst.root.rightChild.leftChild;
+      expect(rootsRightChildsLeftChild.value).toEqual(400);
+    });
+
+    it('should add element 600 to the right of root"s right child', () => {
+      bst.add(600);
+      rootsRightChildsRightChild = bst.root.rightChild.rightChild;
+      expect(rootsRightChildsRightChild.value).toEqual(600);
+    });
+  });
+
+  describe('Check insertion was as expected', () => {
+    it('Inorder traversal of the created bst should be [ 10, 20, 30, 100, 400, 500, 600 ]', () => {
+      expect(bst.traverseInorder()).toEqual([10, 20, 30, 100, 400, 500, 600]);
+    });
+
+    it('Preorder traversal of the created bst should be [ 100, 20, 10, 30, 500, 400, 600 ]', () => {
+      expect(bst.traversePreorder()).toEqual([100, 20, 10, 30, 500, 400, 600]);
+    });
+
+    it('Postorder traversal of the created bst should be [ 10, 30, 20, 400, 600, 500, 100 ]', () => {
+      expect(bst.traversePostorder()).toEqual([10, 30, 20, 400, 600, 500, 100]);
+    });
+  });
+});

Diff for: src/_DataStructures_/Trees/BinarySearchTree/lowest-common-ancestor/index.js

@@ -0,0 +1,24 @@
+/**
+ * Lowest Common Ancestor in a Binary Search Tree.
+ *
+ * Given values of two values n1 and n2 in a Binary Search Tree, find the Lowest Common Ancestor (LCA). You may assume that both the values exist in the tree.
+ */
+ 
+function lca(node, n1, n2) {
+  if (node == null)
+    return null;
+
+  // If both n1 and n2 are smaller than root, then LCA lies in left
+  if (node.value > n1 && node.value > n2)
+    return lca(node.leftChild, n1, n2);
+
+  // If both n1 and n2 are greater than root, then LCA lies in right
+  if (node.value < n1 && node.value < n2)
+    return lca(node.rightChild, n1, n2);
+
+  return node;
+}
+
+module.exports = {
+  lca,
+};

Diff for: src/_DataStructures_/Trees/BinarySearchTree/lowest-common-ancestor/index.test.js

@@ -0,0 +1,28 @@
+const { lca } = require('.');
+const BinarySearchTree = require('../index');
+
+// Quick JSON equivalent
+// {"left":{"left":{"data":4},"right":{"left":{"data":10},"right":{"data":14},"data":12},"data":8},"right":{"data":22},"data":20}
+
+describe('LCA', () => {
+
+  let bst = new BinarySearchTree(20);
+  bst.add(22);
+  bst.add(8);
+  bst.add(12);
+  bst.add(4);
+  bst.add(14);
+  bst.add(10);
+
+  it('Should return 12', () => {
+    expect(lca(bst.root, 10, 14).value).toEqual(12);
+  });
+  
+  it('Should return 8', () => {
+    expect(lca(bst.root, 14, 8).value).toEqual(8);
+  });
+  
+  it('Should return 20', () => {
+    expect(lca(bst.root, 10, 22).value).toEqual(20);
+  });
+});

Diff for: src/_DataStructures_/Trees/SuffixTree/index.js

@@ -1,3 +1,5 @@
+/* eslint-disable max-len */
+/* eslint-disable no-restricted-syntax */
 /* eslint-disable no-plusplus */
 /*
 Implemented by watching this conceptually video: https://www.youtube.com/watch?v=VA9m_l6LpwI
@@ -17,6 +19,7 @@ If found then return the index, else return -1
 
 */
 
+const alphabets = 'abcdefghijklmnopqrstuvwxyz';
 class Node {
   constructor(value, isEnd, index) {
     this.data = value;
@@ -41,7 +44,12 @@ class SuffixTree {
       let currentNode = this.head;
       while (j < currentString.length) {
         if (!currentNode.next.has(currentString[j])) {
-          currentNode.next.set(currentString[j], new Node(currentString, true, i));
+          let nextString = '';
+          while (j < currentString.length) {
+            nextString += currentString[j];
+            j++;
+          }
+          currentNode.next.set(nextString[0], new Node(nextString, true, i));
           break;
         } else {
           let k = 0;
@@ -60,9 +68,20 @@ class SuffixTree {
             diffString += partialMatchString[k];
             k++;
           }
+
           partialMatchNode.data = matchString;
           if (diffString) {
-            partialMatchNode.next.set(diffString[0], new Node(diffString, true, partialMatchNode.index));
+            const oldMap = partialMatchNode.next;
+            const newNode = new Node(diffString, partialMatchNode.isEnd, partialMatchNode.index);
+            const alphabetsArray = alphabets.split('');
+
+            for (const char of alphabetsArray) {
+              if (oldMap.has(char)) {
+                newNode.next.set(char, oldMap.get(char));
+              }
+            }
+            partialMatchNode.next = new Map();
+            partialMatchNode.next.set(diffString[0], newNode);
             partialMatchNode.isEnd = false;
             partialMatchNode.index = null;
           }
@@ -112,10 +131,17 @@ class SuffixTree {
   }
 }
 
-// const s = new SuffixTree('banana');
+// const st = 'asdjkxhcjbzdmnsjakdhasdbajw';
+// const s = new SuffixTree(st);
 // s.constructSuffixTree();
+// // console.log(s.head.next);
 
-//  console.log(s.findSubstring('nana'));
 
+// for (let i = 0; i < st.length; i++) {
+//   const e = st.substring(i);
+//   if (s.findSubstring(e) !== i) {
+//     console.log(e, i, s.findSubstring(e));
+//   }
+// }
 
 module.exports = SuffixTree;

Diff for: src/_Problems_/factorial/index.js

@@ -0,0 +1,8 @@
+function factorial(num) {
+    if (num === 1) return num;
+    else return num * factorial(num - 1);  
+}
+
+module.exports = {
+    factorial,
+  };

Diff for: src/_Problems_/factorial/index.test.js

@@ -0,0 +1,15 @@
+const { factorial } = require('.');
+
+describe('Factorial', () => {
+  it('Should return 24', () => {
+    expect(factorial(4)).toEqual(24);
+  });
+
+  it('Should return 1', () => {
+    expect(factorial(1)).toEqual(1);
+  });
+
+  it('Should return 120', () => {
+    expect(factorial(5)).toEqual(120);
+  });
+});

Diff for: src/_Searching_/JumpSearch/JumpSearch.test.js

@@ -0,0 +1,20 @@
+const { jumpSearch, jumpSearchRecursive } = require('.');
+
+describe('Jump Search', () => {
+    const array = [1, 2, 3, 4, 5, 6, 7, 8];
+    describe('When element to find is at 1st position ', () => {
+        it('Jump search', () => {
+          expect(jumpSearch(array, 1)).toEqual(0);
+        });
+      });
+    describe('When element to find is at last position ', () => {
+        it('Jump search', () => {
+          expect(jumpSearch(array, 7)).toEqual(6);
+        });
+      });
+    describe('When element to find is at random position ', () => {
+        it('Jump search', () => {
+          expect(jumpSearch(array, 3)).toEqual(2);
+        });
+      });
+});

Diff for: src/_Searching_/JumpSearch/index.js

@@ -0,0 +1,38 @@
+/**
+ * Note: Array must be sorted for jump search
+ * Complexity: 
+ * Worst case time complexity: O(√N)
+ * Average case time complexity: O(√N)
+ * Best case time complexity: O(1)
+ * Space complexity: O(1)
+*/
+function jumpSearch(arr, key) {
+    const n = arr.length;
+    const jump = Math.floor(Math.sqrt(n));
+    let step = jump;
+
+    let prev = 0;
+    
+    while(arr[Math.min(step, n) - 1] < key) {
+        prev = step;
+        step += jump;
+        if (prev >= n) 
+            return null; 
+    }
+
+    while(arr[prev] < key) {
+        prev++;
+
+        if (prev == Math.min(step, n))
+            return null;
+    }
+    
+    if (arr[prev] == key) 
+        return prev; 
+
+    return null;
+  }
+  
+  module.exports = {
+    jumpSearch,
+  };

Diff for: src/_Searching_/TernarySearch/TernarySearch.test.js

@@ -0,0 +1,41 @@
+const { ternarySearch, ternarySearchRecursive } = require('.');
+
+describe('Ternary Search', () => {
+  const array = [1, 2, 3, 4, 5, 6, 7, 8];
+  const low = 0;
+  const high = array.length - 1;
+
+  describe('When element to find is at 1st position ', () => {
+    it('Ternary search with Loop', () => {
+      expect(ternarySearch(array, 1)).toEqual(0);
+    });
+    it('Ternary serach with recursion', () => {
+      expect(ternarySearchRecursive(array, low, high, 1)).toEqual(0);
+    });
+  });
+  describe('When element to find is at last position ', () => {
+    it('Ternary search with Loop', () => {
+      expect(ternarySearch(array, 8)).toEqual(7);
+    });
+    it('Ternary serach with recursion', () => {
+      expect(ternarySearchRecursive(array, low, high, 8)).toEqual(7);
+    });
+  });
+  describe('When element to find is at random position ', () => {
+    it('Ternary search with Loop', () => {
+      expect(ternarySearch(array, 3)).toEqual(2);
+    });
+    it('Ternary serach with recursion', () => {
+      expect(ternarySearchRecursive(array, low, high, 4)).toEqual(3);
+    });
+  });
+  describe('When element to find is no present in array ', () => {
+    it('Ternary search with Loop', () => {
+      expect(ternarySearch(array, 10)).toEqual(null);
+    });
+    it('Ternary serach with recursion', () => {
+      expect(ternarySearchRecursive(array, low, high, 10)).toEqual(null);
+    });
+  });
+  
+});