chore: format code

appgurueu · appgurueu · commit 92eb3f3f5a76 · 2023-10-12T01:19:12.000+02:00
diff --git a/Data-Structures/Heap/test/BinaryHeap.test.js b/Data-Structures/Heap/test/BinaryHeap.test.js
@@ -36,7 +36,7 @@ describe('BinaryHeap', () => {
     it('should handle insertion of duplicate values', () => {
       // Check if the heap handles duplicate values correctly
       minHeap.insert(2)
-      console.log(minHeap.heap);
+      console.log(minHeap.heap)
       expect(minHeap.heap).toEqual([1, 3, 2, 4, 8, 6, 2])
     })
 
diff --git a/Data-Structures/Stack/EvaluateExpression.js b/Data-Structures/Stack/EvaluateExpression.js
@@ -6,53 +6,53 @@
  * @returns {number|null} - Result of the expression evaluation, or null if the expression is invalid.
  */
 function evaluatePostfixExpression(expression) {
-  const stack = [];
+  const stack = []
 
   // Helper function to perform an operation and push the result to the stack. Returns success.
   function performOperation(operator) {
-    const rightOp = stack.pop(); // Right operand is the top of the stack
-    const leftOp = stack.pop(); // Left operand is the next item on the stack
+    const rightOp = stack.pop() // Right operand is the top of the stack
+    const leftOp = stack.pop() // Left operand is the next item on the stack
 
     if (leftOp === undefined || rightOp === undefined) {
-      return false; // Invalid expression
+      return false // Invalid expression
     }
     switch (operator) {
       case '+':
-        stack.push(leftOp + rightOp);
-        break;
+        stack.push(leftOp + rightOp)
+        break
       case '-':
-        stack.push(leftOp - rightOp);
-        break;
+        stack.push(leftOp - rightOp)
+        break
       case '*':
-        stack.push(leftOp * rightOp);
-        break;
+        stack.push(leftOp * rightOp)
+        break
       case '/':
         if (rightOp === 0) {
-          return false;
+          return false
         }
-        stack.push(leftOp / rightOp);
-        break;
+        stack.push(leftOp / rightOp)
+        break
       default:
-        return false; // Unknown operator
+        return false // Unknown operator
     }
-    return true;
+    return true
   }
 
-  const tokens = expression.split(/\s+/);
+  const tokens = expression.split(/\s+/)
 
   for (const token of tokens) {
     if (!isNaN(parseFloat(token))) {
       // If the token is a number, push it to the stack
-      stack.push(parseFloat(token));
+      stack.push(parseFloat(token))
     } else {
       // If the token is an operator, perform the operation
       if (!performOperation(token)) {
-        return null; // Invalid expression
+        return null // Invalid expression
       }
     }
   }
 
-  return (stack.length === 1) ? stack[0] : null;
+  return stack.length === 1 ? stack[0] : null
 }
 
-export { evaluatePostfixExpression };
+export { evaluatePostfixExpression }
diff --git a/Data-Structures/Stack/test/EvaluateExpression.test.js b/Data-Structures/Stack/test/EvaluateExpression.test.js
@@ -1,22 +1,21 @@
-import { evaluatePostfixExpression } from '../EvaluateExpression.js';
+import { evaluatePostfixExpression } from '../EvaluateExpression.js'
 
 describe('evaluatePostfixExpression', () => {
   it('should evaluate a valid expression', () => {
-    const expression = '3 4 * 2 / 5 +'; // (3 * 4) / 2 + 5 = 11
-    const result = evaluatePostfixExpression(expression);
-    expect(result).toBe(11);
-  });
+    const expression = '3 4 * 2 / 5 +' // (3 * 4) / 2 + 5 = 11
+    const result = evaluatePostfixExpression(expression)
+    expect(result).toBe(11)
+  })
 
   it('should handle division by zero', () => {
-    const expression = '3 0 /'; // Division by zero
-    const result = evaluatePostfixExpression(expression);
-    expect(result).toBe(null);
-  });
+    const expression = '3 0 /' // Division by zero
+    const result = evaluatePostfixExpression(expression)
+    expect(result).toBe(null)
+  })
 
   it('should handle an invalid expression', () => {
-    const expression = '3 * 4 2 / +'; // Invalid expression
-    const result = evaluatePostfixExpression(expression);
-    expect(result).toBe(null);
-  });
-
-});
+    const expression = '3 * 4 2 / +' // Invalid expression
+    const result = evaluatePostfixExpression(expression)
+    expect(result).toBe(null)
+  })
+})
diff --git a/Maths/test/Determinant.test.js b/Maths/test/Determinant.test.js
@@ -54,10 +54,7 @@ describe('Determinant', () => {
       'Square matrix is required.'
     ],
     [[1, 3, 2, [5, 8, 6], 3], 'Input is not a valid 2D matrix.']
-  ])(
-    'Should return the error message.',
-    (matrix, expected) => {
-      expect(() => determinant(matrix)).toThrowError(expected)
-    }
-  )
+  ])('Should return the error message.', (matrix, expected) => {
+    expect(() => determinant(matrix)).toThrowError(expected)
+  })
 })
