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

Author: ashokdey

README.md

@@ -26,11 +26,17 @@ Collection of interview questions with Unit Tests. Problems includes Data Struct
   - [Baseball Game](src/_DataStructures_/Stack/baseball-game)
   - [Find minimum in the Stack](src/_DataStructures_/Stack/min-stack)
   - [Balanced Parenthesis](src/_DataStructures_/Stack/balanced-parenthesis)
+  - [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)
+  
 
 - [Queue](src/_DataStructures_/Queue)
   - [Weave](src/_DataStructures_/Queue/weave)
 
+- [Doubly Linked List](src/_DataStructures_/DoublyLinkedList)
+- [Suffix Tree](src/_DataStructures_/SuffixTree)
+
 ### Logical Problems
 
 - [Anagrams](src/_Problems_/anagrams)
@@ -57,6 +63,11 @@ Collection of interview questions with Unit Tests. Problems includes Data Struct
 
 - [Binary Search](src/_Searching_/BinarySearch)
 
+### Algorithms
+
+- [LRU Cache](src/_Algorithms_/lru-cache)
+
+
 ### Path Finder
 
 - [A\*](src/PathFinder/AStart)
@@ -66,8 +77,6 @@ Collection of interview questions with Unit Tests. Problems includes Data Struct
 - [Caeser Cipher](src/_Classics_/caeser_cipher)
 - [Fibonacci](src/_Classics_/fibonacci)
 
----
-
 ## CONTRIBUTION Guide
 
 It's great to know that you want to contribute to this repo. Thanks for taking interest. Before you start, read the following carefully.

src/_Algorithms_/lru-cache/index.js

@@ -0,0 +1,71 @@
+/*
+Least recently used (LRU) - cache implementation
+
+get(key) – Get the value (will always be positive) of the key if the key exists in the cache, otherwise return false.
+Complexity: O(1)
+
+set(key, value) – Set or insert the value if the key is not already present. When the cache reached its capacity, it should invalidate the least recently used item before inserting a new item.
+Complexity: O(1)
+*/
+
+const DoublyLinkedList = require('../../_DataStructures_/DoublyLinkedList/index');
+
+class LRUCache {
+  constructor(n) {
+    this.size = n;
+    this.map = new Map();
+    this.list = new DoublyLinkedList();
+  }
+
+  // this method will work in O(1)
+  set(key, value) {
+    const data = {
+      key,
+      value,
+    };
+    if (!this.map.has(key)) {
+      this.list.addAtBeginning(data);
+      this.map.set(key, this.list.head.next);
+
+      if (this.list.length() > this.size) {
+        const lastNode = this.list.tail.previous.data;
+        this.map.delete(lastNode.key);
+        this.list.removeAtEnd();
+      }
+    } else {
+      this.list.remove(this.map.get(key));
+      this.list.addAtBeginning(data);
+      this.map.set(key, this.list.head.next);
+    }
+  }
+
+  // this method will work in O(1)
+  get(key) {
+    if (this.map.has(key)) {
+      const node = this.map.get(key);
+      const { value } = node.data;
+      this.list.remove(node);
+      this.list.addAtBeginning({
+        key,
+        value,
+      });
+      this.map.set(key, this.list.head.next);
+    }
+    return false;
+  }
+}
+
+// const lru = new LRUCache(3);
+// lru.set(1, 1);
+// lru.set(2, 2);
+// lru.set(3, 3);
+// lru.set(4, 4);
+// lru.set(5, 5);
+// lru.set(2, 2);
+// lru.get(5, 5);
+// lru.list.display();
+
+
+module.exports = {
+  LRUCache,
+};

src/_Classics_/fibonacci/index.js

@@ -1,9 +1,11 @@
+//The Fibonacci sequence: 0, 1, 1, 2, 3, 5, 8, 13, 21
 // the algorithm has time complexity of O(n^2), very bad!
 function fibonacci(position) {
   // if position is 1 or 2, the number in fibonacci sequence will be 1
-  if (position < 3) {
-    return 1;
+  if (position <= 1) {
+    return position;
   }
+
   // else the element in fibonacci sequence will be the sum of
   // element at position(p) (p -1) and (p - 2)
   return fibonacci(position - 2) + fibonacci(position - 1);
@@ -24,8 +26,8 @@ function fibonacciMemoized(index, cache) {
   if (cache[index]) {
     return cache[index];
   } else {
-    if (index < 3) {
-      return 1;
+    if (index <=1) {
+      return index;
     } else {
       cache[index] =
         fibonacciMemoized(index - 1, cache) +
@@ -41,7 +43,9 @@ function fibonacciMemoized(index, cache) {
 
 function fibonacciTabular(n) {
   const table = [0, 1];
-
+  if (n <= 1) {
+    return n;
+  }
   for (let i = 2; i <= n; i += 1) {
     table[i] = table[i - 1] + table[i - 2];
   }
@@ -54,4 +58,4 @@ function fibonacciTabular(n) {
 // console.log(`Fib normal - ${fibonacci(number)}`);
 // console.log('--');
 // console.log(`Fib memo - ${fibonacciMemoized(number)}`);
-// console.log(`Fib table - ${fibonacciTabular(number)}`);
+// console.log(`Fib table - ${fibonacciTabular(number)}`);

src/_DataStructures_/DoublyLinkedList/index.js

@@ -0,0 +1,65 @@
+/* eslint-disable class-methods-use-this */
+class Node {
+  constructor(data, previous, next) {
+    this.data = data;
+    this.previous = previous;
+    this.next = next;
+  }
+}
+
+class DoublyLinkedList {
+  constructor() {
+    // head -> tail
+    // head <- tail
+    this.head = new Node(null, null, null);
+    this.tail = new Node(null, null, null);
+    this.head.next = this.tail; // head next point to tail
+    this.tail.previous = this.head; // tail previous point to head
+    this.size = 0;
+  }
+
+  addAtBeginning(value) {
+    const newNode = new Node(value, this.head, this.head.next);
+    this.head.next.previous = newNode;
+    this.head.next = newNode;
+    this.size += 1;
+  }
+
+  addAtEnd(value) {
+    const newNode = new Node(value, this.tail.previous, this.tail);
+    this.tail.previous.next = newNode;
+    this.tail.previous = newNode;
+    this.size += 1;
+  }
+
+  removeAtBeginning() {
+    this.remove(this.head.next);
+    this.size -= 1;
+  }
+
+  removeAtEnd() {
+    this.remove(this.tail.previous);
+    this.size -= 1;
+  }
+
+  remove(node) {
+    const previousNode = node.previous;
+    const nextNode = node.next;
+    previousNode.next = nextNode;
+    nextNode.previous = previousNode;
+  }
+
+  length() {
+    return this.size;
+  }
+
+  display() {
+    let address = this.head.next;
+    while (address !== this.tail) {
+      console.log(address.data);
+      address = address.next;
+    }
+  }
+}
+
+module.exports = DoublyLinkedList;

src/_DataStructures_/LinkedList/loop-in-list/index.js

@@ -1,6 +1,6 @@
 // Floyd’s Cycle-Finding Algorithm
 
-function detechLoop(linkedList) {
+function detectLoop(linkedList) {
   let slow = linkedList.getFirst();
   let fast = linkedList.getFirst();
 
@@ -14,3 +14,7 @@ function detechLoop(linkedList) {
   }
   return false;
 }
+
+module.exports = {
+  detectLoop,
+};

src/_DataStructures_/LinkedList/loop-in-list/loop-in-list.test.js

@@ -0,0 +1,40 @@
+const { LinkedList } = require('../index');
+const { detectLoop } = require('.');
+
+describe('Loop a LinkedList', () => {
+  let loopList = null;
+  let last = null;
+  beforeEach(() => {
+    loopList = new LinkedList();
+    loopList.addAtBeginning('1');
+    loopList.addAtEnd('2');
+    loopList.addAtEnd('3');
+    loopList.addAtEnd('4');
+    loopList.addAtEnd('5');
+    // Create loop in list
+    last = loopList.getLast();
+    last.next = loopList.getFirst();
+  });
+
+  it('Should break for empty list', () => {
+    loopList.delete();
+    expect(() => detectLoop(loopList)).toThrow(TypeError);
+  });
+
+  it('Should return `true` when looping list', () => {
+    expect(detectLoop(loopList)).toEqual(true);
+  });
+
+  it('Should return `false` for non loop list', () => {
+    last.next = null; // remove loop in list
+    expect(detectLoop(loopList)).toEqual(false);
+  });
+
+  it('Should return `false` for non loop list', () => {
+    const list = new LinkedList();
+    list.addAtBeginning('1');
+    list.addAtEnd('1');
+    list.addAtEnd('1');
+    expect(detectLoop(list)).toEqual(false);
+  });
+});

src/_DataStructures_/Stack/postfix-expression-evaluation/index.js

@@ -0,0 +1,40 @@
+/**
+ * Evaluation of Postfix Expression
+ * Input:456*+
+ * Output:34
+ */
+
+const Stack = require('../index');
+
+function evaluatePostfixExpression(expression) {
+    let s = new Stack();
+    for (let i = 0; i < expression.length; i++) {
+        const char = expression[i];
+        if (!isNaN(char)) {
+            //if number push the char onto stack
+            s.push(Number(char));
+        } else {
+            // if char is an operator then pop two elements from stack, evaluate them accordingly based on operator.
+            //push the result to stack 
+            let val1 = s.pop();
+            let val2 = s.pop()
+            switch (char) {
+                case '+':
+                    s.push(val2 + val1);
+                    break;
+                case '-':
+                    s.push(val2 - val1);
+                    break;
+                case '*':
+                    s.push(val2 * val1);
+                    break;
+                case '/':
+                    s.push(val2 / val1);
+                    break;
+
+            }
+        }
+    }
+    //pop the value of postfix expression
+    return s.pop();
+}

src/_DataStructures_/Stack/remove-consecutive-repeated-digits/index.js

@@ -0,0 +1,25 @@
+/**
+ * Given an integer N, remove consecutive repeated digits from it.
+ * Input:133445
+ * Output:1345
+ */
+
+const Stack = require('../index');
+
+
+function removeConsecutiveDigits(no) {
+    let s = new Stack();
+    let newNo = "";
+    //initally push first digit into stack
+    newNo += no[0];
+    s.push(no[0]);
+    for (let i = 1; i < no.length; i++) {
+        const digit = no[i];
+        //if stack top and incoming digit is same ignore it else append to newNo.
+        if (s.peek() !== digit) {
+            newNo += digit;
+            s.push(digit);
+        }
+    }
+    return newNo
+}