Added Hard Ones ✅

Author: Jatin-8898

Hard/Calculator.class

@@ -0,0 +1,110 @@
+import java.util.*;
+
+class Calculator {
+    public static void main(String[] args) {
+        Scanner s = new Scanner(System.in);
+        String str = s.nextLine();
+        System.out.println(calculate(str));
+    }
+
+    public static int calculate(String s) {
+        if(s == null) return 0;
+        
+        int result = 0;
+        int sign = 1;
+        int num = 0;
+
+        Stack<Integer> stack = new Stack<Integer>();
+        stack.push(sign);
+
+        for(int i = 0; i < s.length(); i++) {
+            char c = s.charAt(i);
+
+            if(c >= '0' && c <= '9') {
+                num = num * 10 + (c - '0');
+
+            } else if(c == '+' || c == '-') {
+                result += sign * num;
+                sign = stack.peek() * (c == '+' ? 1: -1); 
+                num = 0;
+
+            } else if(c == '(') {
+                stack.push(sign);
+
+            } else if(c == ')') {
+                stack.pop();
+            }
+        }
+
+        result += sign * num;
+        return result;
+    }
+    public int calculateEditoral(String s) {
+
+        Stack<Integer> stack = new Stack<Integer>();
+        int operand = 0;
+        int result = 0; // For the on-going result
+        int sign = 1;  // 1 means positive, -1 means negative
+
+        for (int i = 0; i < s.length(); i++) {
+
+            char ch = s.charAt(i);
+            if (Character.isDigit(ch)) {
+
+                // Forming operand, since it could be more than one digit
+                operand = 10 * operand + (int) (ch - '0');
+
+            } else if (ch == '+') {
+
+                // Evaluate the expression to the left,
+                // with result, sign, operand
+                result += sign * operand;
+
+                // Save the recently encountered '+' sign
+                sign = 1;
+
+                // Reset operand
+                operand = 0;
+
+            } else if (ch == '-') {
+
+                result += sign * operand;
+                sign = -1;
+                operand = 0;
+
+            } else if (ch == '(') {
+
+                // Push the result and sign on to the stack, for later
+                // We push the result first, then sign
+                stack.push(result);
+                stack.push(sign);
+
+                // Reset operand and result, as if new evaluation begins for the new sub-expression
+                sign = 1;
+                result = 0;
+
+            } else if (ch == ')') {
+
+                // Evaluate the expression to the left
+                // with result, sign and operand
+                result += sign * operand;
+
+                // ')' marks end of expression within a set of parenthesis
+                // Its result is multiplied with sign on top of stack
+                // as stack.pop() is the sign before the parenthesis
+                result *= stack.pop();
+
+                // Then add to the next operand on the top.
+                // as stack.pop() is the result calculated before this parenthesis
+                // (operand on stack) + (sign on stack * (result from parenthesis))
+                result += stack.pop();
+
+                // Reset the operand
+                operand = 0;
+            }
+        }
+        return result + (sign * operand);
+    }
+
+}
+

Hard/Calculator.java

@@ -0,0 +1,62 @@
+import java.util.*;
+class InsertInterval{    
+    public int[][] insert(int[][] intervals, int[] newInterval) {
+        
+        if ((intervals.length == 0) || (intervals[0].length == 0))
+            return new int[][]{newInterval};
+
+        List<int[]> ints = new ArrayList<>(Arrays.asList(intervals));
+
+        ints.add(searchInsertPosition(intervals, newInterval), newInterval);
+
+        return mergeIntervals(ints).toArray(new int[][]{{0}});
+    }
+
+    // 	LC 35 Search Insert Position    
+    private int searchInsertPosition(int[][] intervals, int[] newInterval) {
+        int target = newInterval[0];
+
+        if (target <= intervals[0][0])
+            return 0;
+
+        if (target >= intervals[intervals.length - 1][0])
+            return intervals.length;
+
+        int low = 0;
+        int high = intervals.length - 1;
+
+        while (low <= high) {
+            int mid = (low + high) / 2;
+            
+            if (intervals[mid][0] == target)
+                return mid;
+            
+            if (intervals[mid][0] > target)
+                high = mid - 1;
+            else
+                low = mid + 1;
+        }
+        return low;
+    }
+
+    // LC 56 Merge Intervals
+    private List<int[]> mergeIntervals(List<int[]> ints) {
+
+        List<int[]> merged = new ArrayList<>();
+        int[] lastInt = ints.get(0);
+        merged.add(lastInt);
+
+        for (int i = 1; i < ints.size(); i++) {
+            int[] currInt = ints.get(i);
+
+            if (currInt[0] <= lastInt[1]) {
+                lastInt[1] = Math.max(lastInt[1], currInt[1]);
+
+            } else {
+                merged.add(currInt);
+                lastInt = currInt;
+            }
+        }
+        return merged;
+    }
+}

Hard/InsertInterval.java

@@ -0,0 +1,29 @@
+class JumpGameII {
+    public static void main(String[] args) {
+        int[] a = {2,3,1,1,4}; 
+        System.out.println(jump(a));
+    }
+    public static int jump(int[] A) {
+        //This is an implicit bfs solution. i == curEnd means you visited all the items on the current level. Incrementing jumps++ is like incrementing the level you are on. And curEnd = max is like getting the queue size (level size) for the next level you are traversing. 
+        
+        int jumps = 0, 
+            curEnd = 0, 
+            max = 0;
+        
+        //i < A.length - 1 BECAUSE The last number doesn't need to be traversed. The question just needs to reach to the last number, then it ends and then outputs the result.
+        
+        for (int i = 0; i < A.length - 1; i++) {
+        
+            max = Math.max(max, i + A[i]);
+            //System.out.println("MAX "+max + " "+i+ " " +A[i]);
+
+            if (i == curEnd) {
+                jumps++;
+                curEnd = max;
+                //System.out.println("JUMPS "+jumps+" " +curEnd);
+            }
+        }
+        
+        return jumps;
+    }
+}