solves #224: Basic Calculator in java

Author: anishLearnsToCode

README.md

@@ -190,6 +190,7 @@
 | 221  | [Maximal Square](https://leetcode.com/problems/maximal-square)                                                                                                         |                                                                                        [![Java](assets/java.png)](src/MaximalSquare.java)                                                                                        |                                                                                                                                   |
 | 222  | [Count Complete Tree Nodes](https://leetcode.com/problems/count-complete-tree-nodes)                                                                                   |                                                                                   [![Java](assets/java.png)](src/CountCompleteTreeNodes.java)                                                                                    |                                                                                                                                   |
 | 223  | [Rectangle Area](https://leetcode.com/problems/rectangle-area)                                                                                                         |                                                                                        [![Java](assets/java.png)](src/RectangleArea.java)                                                                                        |                                                                                                                                   |
+| 224  | [Basic Calculator](https://leetcode.com/problems/basic-calculator)                                                                                                     |                                                                                       [![Java](assets/java.png)](src/BasicCalculator.java)                                                                                       |                                                                                                                                   |
 | 225  | [Implement Stack using Queues](https://leetcode.com/problems/implement-stack-using-queues)                                                                             |                                                       [![Java](assets/java.png)](src/MyStack.java) [![Python](assets/python.png)](python/implement_stack_using_queues.py)                                                        |                                                                                                                                   |
 | 226  | [Invert Binary Tree](https://leetcode.com/problems/invert-binary-tree)                                                                                                 |                                                        [![Java](assets/java.png)](src/InvertBinaryTree.java) [![Python](assets/python.png)](python/invert_binary_tree.py)                                                        |                                                                                                                                   |
 | 227  | [Basic Calculator II](https://leetcode.com/problems/basic-calculator-ii)                                                                                               |                                                                                      [![Java](assets/java.png)](src/BasicCalculatorII.java)                                                                                      |                                                                                                                                   |

src/BasicCalculator.java

@@ -0,0 +1,38 @@
+import java.util.Stack;
+
+class BasicCalculator {
+    public int calculate(String s) {
+        final Stack<Integer> stack = new Stack<Integer>();
+        int number = 0;
+        int result = 0; // For the ongoing result
+        int sign = 1;  // 1 means positive, -1 means negative
+
+        for (int i = 0; i < s.length(); i++) {
+            final char ch = s.charAt(i);
+
+            if (Character.isDigit(ch)) {
+                number = 10 * number + (ch - '0');
+            } else if (isOperator(ch)) {
+                result += sign * number;
+                number = 0;
+                sign = ch == '+' ? 1 : -1;
+            } else if (ch == '(') {
+                stack.push(result);
+                stack.push(sign);
+                sign = 1;
+                result = 0;
+            } else if (ch == ')') {
+                result += sign * number;
+                result *= stack.pop();
+                result += stack.pop();
+                number = 0;
+            }
+        }
+
+        return result + (sign * number);
+    }
+
+    private static boolean isOperator(char c) {
+        return c == '+' || c == '-';
+    }
+}

src/HelloWorld.java

@@ -1,80 +1,35 @@
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
+import java.util.Set;
+import java.util.Stack;
 
 public class HelloWorld {
-    public static int[][] insert(int[][] intervals, int[] newInterval) {
-        if (intervals.length == 0) {
-            return new int[][] { newInterval };
-        }
-
-        final int startIndex = binarySearch(intervals, newInterval[0]);
-
-        final List<int[]> result = new ArrayList<>();
-        for (int i = 0 ; i < startIndex ; i++) {
-            result.add(intervals[i]);
-        }
-        result.add(newInterval);
-        for (int i = startIndex ; i < intervals.length ; i++) {
-            result.add(intervals[i]);
-        }
-
-        return mergeIntervals(result);
-    }
-
-    private static int[][] mergeIntervals(List<int[]> intervals) {
-        final List<int[]> result = new ArrayList<>();
-        int start = intervals.getFirst()[0], end = intervals.getFirst()[1];
-        for (int[] interval : intervals) {
-            if (interval[0] <= end) {
-                end = Math.max(interval[1], end);
+    private static final Set<String> OPERATORS = Set.of("+", "-", "*", "/");
+
+    public int evalRPN(String[] tokens) {
+        final Stack<Integer> stack = new Stack<>();
+        for (String token : tokens) {
+            if (isOperator(token)) {
+                final int second = stack.pop();
+                final int first = stack.pop();
+                final int result = apply(token, first, second);
+                stack.push(result);
             } else {
-                result.add(new int[]{start, end});
-                start = interval[0];
-                end = interval[1];
+                stack.push(Integer.parseInt(token));
             }
         }
-        result.add(new int[] { start, end });
-        return toArray(result);
+        return stack.peek();
     }
 
-    private static int binarySearch(int[][] intervals, int x) {
-        int left = 0, right = intervals.length - 1, middle;
-        while (left <= right) {
-            middle = left + (right - left) / 2;
-            if (intervals[middle][0] == x) return middle;
-            else if (intervals[middle][0] < x) left = middle + 1;
-            else right = middle - 1;
-        }
-        return left;
+    private static boolean isOperator(String token) {
+        return OPERATORS.contains(token);
     }
 
-    private static int[][] toArray(List<int[]> intervals) {
-        final int[][] result = new int[intervals.size()][2];
-        int k = 0;
-        for (int[] interval : intervals) {
-            result[k++] = interval;
-        }
-        return result;
-    }
-
-    public static void main(String[] args) {
-//        System.out.println(Arrays.deepToString(
-//                insert(new int[][]{{1, 3}, {6, 9}}, new int[] {2, 5})
-//        ));
-
-//        System.out.println(Arrays.deepToString(
-//                insert(
-//                        new int[][] {{1, 2}, {3, 5}, {6, 7}, {8, 10}, {12, 16}},
-//                        new int[] {4, 8}
-//                )
-//        ));
-
-        System.out.println(Arrays.deepToString(
-                insert(
-                        new int[][] {{1, 3}, {6, 9}},
-                        new int[] {2, 5}
-                )
-        ));
+    private static int apply(String operator, int first, int second) {
+        return switch (operator) {
+            case "+" -> first + second;
+            case "-" -> first - second;
+            case "/" -> first / second;
+            case "*" -> first * second;
+            default -> 0;
+        };
     }
 }