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

Author: ashokdey

README.md

@@ -51,7 +51,7 @@ Collection of interview questions with Unit Tests. Problems includes Data Struct
 - [FizzBuzz](src/_Problems_/fizzbuzz)
 - [String Permutaions](src/_Problems_/get-string-permutations)
 - [Get Subsequence](src/_Problems_/get_subsequence)
-- [Get Maze Path](src/_Problems_/get_subsequence)
+- [Get Maze Path](src/_Problems_/get-mazePath)
 - [Get longest consecutive 1s](src/_Problems_/max-consecutive-1s)
 - [Get Max Char](src/_Problems_/maxchar)
 - [Get Smallest Common Number](src/_Problems_/get-smallest-common-number)

src/_DataStructures_/DoublyLinkedList/index.js

@@ -55,10 +55,12 @@ class DoublyLinkedList {
 
   display() {
     let address = this.head.next;
+    let addresses = []
     while (address !== this.tail) {
-      console.log(address.data);
+      addresses.push(address.data)
       address = address.next;
     }
+    return addresses
   }
 }
 

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

@@ -15,9 +15,9 @@ function evaluatePostfixExpression(expression) {
             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 
+            //push the result to stack
             let val1 = s.pop();
-            let val2 = s.pop()
+            let val2 = s.pop();
             switch (char) {
                 case '+':
                     s.push(val2 + val1);
@@ -38,3 +38,7 @@ function evaluatePostfixExpression(expression) {
     //pop the value of postfix expression
     return s.pop();
 }
+
+module.exports = {
+  evaluatePostfixExpression,
+};

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

@@ -0,0 +1,55 @@
+const { evaluatePostfixExpression } = require('.');
+
+describe('Postfix expression evaluation', function () {
+  it('should be a function', function () {
+    expect(typeof evaluatePostfixExpression).toEqual('function');
+  });
+  
+  it('should return a number', function () {
+    const expression = '11+';
+    
+    expect(typeof evaluatePostfixExpression(expression)).toEqual('number')
+  });
+  
+  it('should handle addition', function () {
+    const expression = '23+';
+    const expected = 5;
+    
+    expect(evaluatePostfixExpression(expression)).toEqual(expected);
+  });
+  
+  it('should handle subtraction', function () {
+    const expression = '54-';
+    const expected = 1;
+    
+    expect(evaluatePostfixExpression(expression)).toEqual(expected);
+  });
+  
+  it('should handle multiplication', function () {
+    const expression = '34*';
+    const expected = 12;
+    
+    expect(evaluatePostfixExpression(expression)).toEqual(expected);
+  });
+  
+  it('should handle division', function () {
+    const expression = '62/';
+    const expected = 3;
+    
+    expect(evaluatePostfixExpression(expression)).toEqual(expected);
+  });
+  
+  it('should handle negative numbers', function () {
+    const expression = '25-';
+    const expected = -3;
+    
+    expect(evaluatePostfixExpression(expression)).toEqual(expected);
+  });
+  
+  it('should handle multiple operators', function () {
+    const expression = '123*+';
+    const expected = 7;
+    
+    expect(evaluatePostfixExpression(expression)).toEqual(expected);
+  });
+});

src/_Problems_/get-mazePath/get-mazePath.test.js

@@ -0,0 +1,41 @@
+const { getMazePath } = require('.');
+
+describe('Get maze path', () => {
+  it('returns all possible solutions for a 2x2 grid', () => {
+    const expectedSolutions = ['HHVV', 'HVHV', 'HVVH', 'VHHV', 'VHVH', 'VVHH'];
+
+    expect(getMazePath(0, 0, 2, 2)).toEqual(expectedSolutions);
+  });
+
+  it('returns an even amount of horizontal and vertical movements', () => {
+    const solutions = getMazePath(0, 0, 3, 3);
+
+    solutions.forEach(solution => {
+      expect(solution.length).toEqual(6);
+
+      expect(solution.match(/H/g).length).toEqual(3);
+      expect(solution.match(/V/g).length).toEqual(3);
+    });
+  });
+
+  it('returns the expected number of solutions based on given grids', () => {
+    expect(getMazePath(0, 0, 1, 1).length).toEqual(2);
+    expect(getMazePath(0, 0, 2, 2).length).toEqual(6);
+    expect(getMazePath(0, 0, 3, 3).length).toEqual(20);
+    expect(getMazePath(0, 0, 4, 4).length).toEqual(70);
+
+    expect(getMazePath(1, 1, 4, 4).length).toEqual(20);
+  });
+
+  it('returns an empty array when the start and end coordinates are equal', () => {
+    const solutions = getMazePath(2, 2, 2, 2);
+
+    expect(solutions).toEqual(['']);
+  });
+
+  it('returns an empty array when the start coordinates are greater than the end coordinates', () => {
+    const solutions = getMazePath(2, 2, 1, 1);
+
+    expect(solutions).toEqual([]);
+  });
+});

src/_Problems_/get-mazePath/index.js

@@ -7,10 +7,7 @@
 // --->> er = end row
 // --->> ec = end column
 
-
-
-
-let getMazePath = (cr, cc, er, ec) => {
+const getMazePath = (cr, cc, er, ec) => {
     if(cr == er && cc == ec) {              //============POSITIVE BASE CASE===========
         let br = [];
         br.push('');
@@ -37,6 +34,4 @@ let getMazePath = (cr, cc, er, ec) => {
     return myResult;
 }
 
-
-let path = getMazePath(0, 0, 2, 2);
-console.log(path);
+module.exports = { getMazePath };