solves basic calcuator ii in java

Author: anishLearnsToCode

README.md

@@ -183,7 +183,7 @@
 | 223  | [Rectangle Area](https://leetcode.com/problems/rectangle-area)                                                                                            |                                                                  [![Java](assets/java.png)](src/RectangleArea.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)                                  |                                                                                                                                   |
-| 228  | [Basic Calculator II](https://leetcode.com/problems/basic-calculator-ii)                                                                                  |                                                                                                                                                                                      |                                                                                                                                   |
+| 227  | [Basic Calculator II](https://leetcode.com/problems/basic-calculator-ii)                                                                                  |                                                                [![Java](assets/java.png)](src/BasicCalculatorII.java)                                                                |                                                                                                                                   |
 | 229  | [Majority Element II](https://leetcode.com/problems/majority-element-ii)                                                                                  |                                                                                                                                                                                      |                                                                                                                                   |
 | 230  | [Kth Smallest Element in a BST](https://leetcode.com/problems/kth-smallest-element-in-a-bst)                                                              |                                                                                                                                                                                      |                                                                                                                                   |
 | 231  | [Power of Two](https://leetcode.com/problems/power-of-two)                                                                                                |                                        [![Java](assets/java.png)](src/PowerOf2.java) [![Python](assets/python.png)](python/is_power_of_2.py)                                         |                                                                                                                                   |

src/BasicCalculatorII.java

@@ -0,0 +1,88 @@
+// https://leetcode.com/problems/basic-calculator-ii
+// extremely innovative approach, using a grammar to evaluate expressions
+// T: O(N)
+// S: O(1)
+
+import java.util.Set;
+
+public class BasicCalculatorII {
+    private static final char ADDITION = '+';
+    private static final char SUBTRACTION = '-';
+    private static final char MULTIPLICATION = '*';
+    private static final char DIVISION = '/';
+    private static final char SPACE = ' ';
+    
+    private static final Set<Character> ADDITIVE_OPERATORS = Set.of(ADDITION, SUBTRACTION);
+    private static final Set<Character> MULTIPLICATIVE_OPERATORS = Set.of(MULTIPLICATION, DIVISION);
+    
+    private String expression;
+    private int index;
+
+    public int calculate(String s) {
+        this.expression = s;
+        this.index = 0;
+        return addition();
+    }
+
+    private int addition() {
+        int sum = multiplication();
+        while (index < expression.length() && isAdditiveOperator(expression.charAt(index))) {
+            char operator = expression.charAt(index++);
+            sum = applyOperator(sum, multiplication(), operator);
+        }
+        return sum;
+    }
+
+    private int multiplication() {
+        int result = toNumber();
+        while (index < expression.length() && isMultiplicativeOperator(expression.charAt(index))) {
+            char operator = expression.charAt(index++);
+            result = applyOperator(result, toNumber(), operator);
+        }
+        return result;
+    }
+    
+    private int toNumber() {
+        int number = 0;
+        while (index < expression.length() && isDigitOrSpace(expression.charAt(index))) {
+            if (isSpace(expression.charAt(index))) {
+                index++;
+                continue;
+            }
+            number *= 10;
+            number += toDigit(expression.charAt(index));
+            index++;
+        }
+        return number;
+    }
+    
+    private int toDigit(char digit) {
+        return digit - '0';
+    }
+
+    private boolean isDigitOrSpace(char c) {
+        return Character.isDigit(c) || isSpace(c);
+    }
+
+    private boolean isSpace(char c) {
+        return c == SPACE;
+    }
+
+    private int applyOperator(int a, int b, char operator) {
+        return switch (operator) {
+            case ADDITION -> a + b;
+            case SUBTRACTION -> a - b;
+            case MULTIPLICATION -> a * b;
+            case DIVISION -> a / b;
+            default -> throw new IllegalStateException("Unexpected value: " + operator);
+        };
+    }
+    
+    private boolean isAdditiveOperator(char operator) {
+        return ADDITIVE_OPERATORS.contains(operator);
+    }
+    
+    private boolean isMultiplicativeOperator(char operator) {
+        return MULTIPLICATIVE_OPERATORS.contains(operator);
+    }
+}